Generics (F#)
F# funkce agregace typy jako třídy, záznamů a hodnoty vlastností, metod a discriminated sdružení může být generic.Obecné konstrukce obsahovat nejméně jeden parametr typu obvykle poskytne uživatel obecné konstrukce.Obecné funkce a typy můžete napsat kód, který pracuje s různými typy bez opakováním kód pro každý typ.Provedení obecný kód může být jednoduché F#, protože často kódu je implicitně odvodit být obecný odvození typu kompilátoru a mechanismy automatického generalizace.
// Explicitly generic function.
let function-name<type-parameters> parameter-list =
function-body
// Explicitly generic method.
[ static ] member object-identifer.method-name<type-parameters> parameter-list [ return-type ] =
method-body
// Explicitly generic class, record, interface, structure,
// or discriminated union.
type type-name<type-parameters> type-definition
Poznámky
Prohlášení výslovně Obecné funkce nebo typ podobá se Obecné funkce nebo typu, s výjimkou pro specifikaci (a použití) parametry typu v lomených závorkách za názvem funkce nebo typu.
Často jsou implicitně obecné prohlášení.Není plně určit typ každý parametr, který se používá k vytvoření funkci nebo typ kompilátor pokusí odvození typu každý parametr, hodnota a proměnné z kódu, který napíšete.Další informace naleznete v tématu Odvození typu (F#).Pokud kód pro typ nebo funkce nejsou jinak omezit typy parametrů, funkci nebo typ je implicitně obecný.Tento proces se nazývá Automatické generalizace.Existují určitá omezení na automatické generalizace.Například pokud je F# kompilátor nelze odvodit typy pro obecné konstrukce, kompilátor ohlásí chybu, která se týká omezení nazývá hodnotu omezení.V takovém případě budete muset přidat některé anotace type.Další informace o automatické Generalizace a hodnota omezení a změna kódu k řešení tohoto problému naleznete v Automatické generalizace (F#).
V syntaxi předchozí type-parameters je čárkami oddělený seznam parametrů, které představují neznámé typy z nichž každé začíná jednoduché uvozovky, volitelně s klauzule constraint, která dále omezuje typy mohou být použity pro typ parametru.Syntaxi klauzule constraint různých druhů a další informace o omezeních naleznete v Omezení (F#).
type-definition Syntaxe je stejná jako definice typu jiného než obecného typu.Obsahuje parametry konstruktoru pro typ třídy, volitelným as klauzule, rovná symbol, pole záznamu inherit klauzule, možnosti pro discriminated unie, let a do vazby, definice členské a nic jiného povoleno v definici typu Obecné.
Ostatní prvky syntaxe jsou stejné jako u funkce obecné a typy.Například object-identifier je identifikátor, který představuje obsahující objekt samotný.
Vlastnosti polí a konstruktory nemohou být obecnější než nadřazeného typu.Také v modulu nemohou být obecné.
Implicitně obecné konstrukce
Když kompilátor F# odvodí typy kódu, automaticky zpracovává veškeré funkce, která může být jako obecné obecný.Pokud zadáte typ explicitně, jako například typ parametru, zabránit automatické generalizace.
V následujícím příkladu kódu makeList je obecný, i když jej ani jeho parametry jsou explicitně deklarovány jako obecný.
let makeList a b =
[a; b]
Podpis funkce je odvodit se 'a -> 'a -> 'a list.Všimněte si, že a a b v tomto příkladu odvodit mít stejného typu.Je to proto, že jsou zahrnuty do seznamu společně a všechny prvky seznamu musí být stejného typu.
Funkci lze také nastavit obecný znamenat, že parametr typ je obecný typ parametru pomocí syntaxe jednoduché uvozovky v anotaci typu.V následujícím kódu function1 je obecný, protože jeho parametry jsou deklarovány tímto způsobem jako parametry typu.
let function1 (x: 'a) (y: 'a) =
printfn "%A %A" x y
Konstrukce explicitně obecný
Lze také nastavit funkci obecný explicitně prohlášením jeho parametry typu v lomených závorkách (< >).Následující kód toto zobrazuje.
let function2<'T> x y =
printfn "%A, %A" x y
Pomocí obecné konstrukce
Při použití Obecné funkce nebo metody nemáte zadat argumenty typu.Kompilátor používá odvození typu odvodit odpovídající typ argumentů.Pokud je stále nejednoznačnosti, je zadat argumenty typu v lomených závorkách čárkou oddělující více argumentů typu.
Následující kód ukazuje použití funkce, které jsou definovány v předchozích částech.
// In this case, the type argument is inferred to be int.
function1 10 20
// In this case, the type argument is float.
function1 10.0 20.0
// Type arguments can be specified, but should only be specified
// if the type parameters are declared explicitly. If specified,
// they have an effect on type inference, so in this example,
// a and b are inferred to have type int.
let function3 a b =
// The compiler reports a warning:
function1<int> a b
// No warning.
function2<int> a b
[!POZNÁMKA]
Obecný typ odkazovat podle názvu dvěma způsoby.Například list<int> a int list jsou dva způsoby, jak odkazovat na obecný typ list , má jeden typ argumentu int.Tento formulář je konvenčně používány pouze s předdefinované typy F# jako list a option.Je-li více argumentů, obvykle pomocí syntaxe Dictionary<int, string> , ale můžete také použít syntaxi (int, string) Dictionary.
Zástupné znaky jako argumenty typu
Chcete-li určit, že argument typ dovozovat kompilátorem, můžete použít namísto argument s názvem typ podtržení nebo zástupný symbol (_).To je ukázáno v následujícím kódu.
let printSequence (sequence1: Collections.seq<_>) =
Seq.iter (fun elem -> printf "%s " (elem.ToString())) sequence1
Omezení v obecných typech a funkce
Obecný typ nebo definice funkce můžete použít pouze konstrukce, které jsou k dispozici na obecný typ parametru známé.To je nutné povolit ověřování volání funkce a metody v době kompilace.Pokud explicitně deklarovat parametry do typu, můžete použít explicitní omezení obecný typ parametru upozornění kompilátoru určitých funkcí a metody jsou k dispozici.Však povolíte kompilátor F# odvodit vaše typy parametrů Obecné, bude zjistit příslušné omezení pro vás.Další informace naleznete v tématu Omezení (F#).
Staticky vyřešen parametry typu
Existují dva druhy parametry typu, které lze použít v aplikacích F#.První jsou parametry obecný typ typu popsaného v předchozích částech.Tento typ první parametr typu odpovídá obecný typ parametry, které jsou použity v jazycích, jako jsou například Visual Basic a C#.Jiný druh parametr typu je specifický pro F# a je označována jako staticky vyřešen parametr typu.Informace o těchto konstrukcí, Staticky vyřešen parametry typu (F#).
Příklady
// A generic function.
// In this example, the generic type parameter 'a makes function3 generic.
let function3 (x : 'a) (y : 'a) =
printf "%A %A" x y
// A generic record, with the type parameter in angle brackets.
type GR<'a> =
{
Field1: 'a;
Field2: 'a;
}
// A generic class.
type C<'a>(a : 'a, b : 'a) =
let z = a
let y = b
member this.GenericMethod(x : 'a) =
printfn "%A %A %A" x y z
// A generic discriminated union.
type U<'a> =
| Choice1 of 'a
| Choice2 of 'a * 'a
type Test() =
// A generic member
member this.Function1<'a>(x, y) =
printfn "%A, %A" x y
// A generic abstract method.
abstract abstractMethod<'a, 'b> : 'a * 'b -> unit
override this.abstractMethod<'a, 'b>(x:'a, y:'b) =
printfn "%A, %A" x y
Viz také
Referenční dokumentace
Staticky vyřešen parametry typu (F#)