Generics (F#)

Makale
02/28/2013

F# işlevi değerleri, yöntemleri, özellikleri ve toplama sınıfları gibi türleri kaydeder ve discriminated sendikalar olabilir Genel. Genel yapıları genellikle genel yapısı kullanıcı tarafından sağlanan en az bir tür parametresi içerir. Genel işlevleri ve türleri çeşitli türleri kod her türü için yinelenen olmadan çalışan kod yazmanızı sağlar. Genellikle kodunuzu örtülü olarak genel olarak derleyici 's tür kesmesi ve otomatik genelleştirmesi mekanizmaları tarafından algılanır çünkü kodunuzu genel yapma F# basit olabilir.

// 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

Notlar

Bildiriminde açıkça genel işlevini veya türünü, çok genel olmayan işlev veya işlevini veya türünü adından sonra köşeli parantez içinde türü parametre belirtimi (ve kullanım) haricinde türü gibidir.

Bildirimleri genellikle dolaylı olarak geneldir. Tam olarak işlevini veya türünü oluşturmak için kullanılan her parametrenin türünü belirtmezseniz, derleyici sizin yazacağınız koda değişkeninden her parametre ve değer türü gerçekleştirip dener. Daha fazla bilgi için bkz. Tür kesmesi (F#). Kod türü ya da işlev Aksi halde parametre türleri sınırlamak değil, işlevi veya türü örtülü olarak genel. Bu işlem adlı Otomatik genelleştirmesi. Otomatik genelleştirmesi üzerinde bazı sınırlamaları vardır. Örneğin, F# derleyicisi, genel bir yapı türlerinde gerçekleştirip yapamıyorsa, derleyici adlı bir kısıtlama başvuran bir hata bildirir değer kısıtlaması. Bu durumda, bazı tür ek açıklamaları eklemek zorunda kalabilirsiniz. Otomatik genelleştirmesi ve değer kısıtlaması ve sorunu gidermek için kodunuzu değiştirme hakkında daha fazla bilgi için bkz: Otomatik genelleştirmesi (F#).

Önceki sözdiziminde, type-parameters her biri hangi türleri daha fazla sınırlayan isteğe bağlı olarak CONSTRAINT yan tümcesi ile tek bir tırnak işareti ile başlar virgülle ayrılmış listesini bilinmeyen türlerini temsil parametreleri bu tür parametresi için kullanılan. Sözdizimi kısıtlaması yan tümceleri çeşitli türleri ve kısıtlamaları hakkında diğer bilgiler için bkz: Kısıtlamaları (F#).

type-definition Sözdiziminde genel olmayan türü için tür tanımı ile aynıdır. İsteğe bağlı bir sınıf türü için yapıcı parametreleri içeren as yan tümcesi, eşit sembolü, kayıt alanları inherit yan tümcesi, bir discriminated Birliği seçimleri let ve do bağları, üye tanımları ve başka bir şey olmayan genel tür tanımında izin.

Sözdizimi öğeleri genel olmayan işlevler ve türleri için aynıdır. Örneğin, object-identifier içeren nesneyi gösteren bir tanımlayıcıdır.

Özellikler, alanlar ve kurucular kapsayan türünden daha genel olamaz. Ayrıca, Modül içindeki değerleri genel olamaz.

Örtülü olarak genel yapıları

F# derleyicisi kodunuzu türlerinde yorumlar, genel olarak genel herhangi bir işlevi otomatik olarak değerlendirir. Bir tür bir parametre türü gibi açıkça belirtirseniz, otomatik genelleştirmesi engeller.

Aşağıdaki kod örneği, makeList ne onu ne de kendi parametreleri açıkça genel olarak bildirilen olsa, geneldir.

let makeList a b =
    [a; b]

İşlev imzası olmasını olayla 'a -> 'a -> 'a list. Dikkat a ve b Bu örnekte, aynı türde olması algılanır. Bunun nedeni, bir listede birlikte eklenir ve listesinin tüm öğeler aynı türde olmalıdır olmasıdır.

Aynı zamanda bir işlev parametre türü genel bir tür parametresiyle olduğunu belirtmek için tür ek açıklaması tek tırnak işareti sözdizimini kullanarak genel duruma getirebilirsiniz. Aşağıdaki kodda, function1 parametrelerini bu şekilde türü parametre olarak bildirildiði için geneldir.

let function1 (x: 'a) (y: 'a) =
    printfn "%A %A" x y

Açıkça genel yapıları

Ayrıca bir işlev türü parametrelerinin açılı ayraçlar içinde açıkça bildirerek genel yapabilirsiniz (< >). Aşağıdaki kod bunu göstermektedir.

let function2<'T> x y =
    printfn "%A, %A" x y

Generic kullanarak yapıları

Genel işlevler veya yöntemler kullandığınızda, tür bağımsız değişkenleri belirtmek olmayabilir. Derleyici tür kesmesi gerçekleştirip uygun tür bağımsız değişkenleri kullanır. Yine de bir belirsizlik varsa, birden fazla tür bağımsız değişkenleri virgüllerle ayırarak açılı ayraçlar içindeki tür bağımsız değişkenleri sağlayabilir.

Aşağıdaki kod önceki kısımlarında tanımlanan işlevleri kullanımını göstermektedir.

// 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

Not

Genel bir tür adıyla başvurmak için iki yol vardır.Örneğin, list<int> ve int list için genel bir tür başvurmak için iki yol olduğunu list tek tür bağımsız değişkeni olan int.İkinci form geleneksel olarak yalnızca yerleşik F# türlerinde gibi kullanılır list ve option.Çok sayıda tür bağımsız değişkeni varsa, sözdizimi normalde kullandığınız Dictionary<int, string> sözdizimini de kullanabilirsiniz, ancak (int, string) Dictionary.

Tür bağımsız değişkenleri olarak joker karakterler

Tür bağımsız değişkeni derleyici tarafından çıkarılmamalıdır belirtmek için adlandırılmış türü değişkeni yerine alt çizgi veya joker karakter simgesi (_) kullanabilirsiniz. Bu, aşağıdaki kodu gösterilir.

let printSequence (sequence1: Collections.seq<_>) =
   Seq.iter (fun elem -> printf "%s " (elem.ToString())) sequence1

Genel türler ve işlevleri kısıtlamaları

Genel tür veya işlev tanımı genel tür parametresi kullanılabilir olması için bilinen yapıları kullanabilirsiniz. Bu işlev ve yöntem çağrıları doğrulamayı derleme zamanında etkinleştirmek için gereklidir. Sizin tür parametreleri açıkça bildirirseniz derleyici belirli yöntemler ve işlevleri kullanılabilir olduğunu bildirmek için bir genel tür parametresi açık bir kısıtlaması uygulayabilirsiniz. Sizin genel parametre türleri gerçekleştirip F# derleyicisi izin, ancak bunu uygun sınırlamalar sizin için belirleyecektir. Daha fazla bilgi için bkz. Kısıtlamaları (F#).

Tür parametreleri statik olarak çözüldü

İki tür F# programlarında kullanılan tür parametreleri vardır. İlk tür önceki bölümlerde açıklanan genel türde parametreler bulunur. Tür parametresi ilk bu tür gibi Visual Basic ve C# dillerinde kullanılan genel türde parametreler eşdeğerdir. Başka tür bir tür parametresi F# özeldir ve olarak başvurulan bir Tür parametresi'statik olarak çözümlenen. Bu yapıları hakkında daha fazla bilgi için bkz: Tür parametreleri (F#) statik olarak çözüldü.

Örnekler

// 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