Genel Türler

F# işlev değerleri, yöntemler, özellikler ve sınıflar, kayıtlar ve ayrımlı union'lar gibi toplama türleri genel olabilir. Genel yapılar, genellikle genel yapının kullanıcısı tarafından sağlanan en az bir tür parametresi içerir. Genel işlevler ve türler, her tür için kodu yinelemeden çeşitli türlerle çalışan kod yazmanız için olanak sağlar. Genellikle kodunuz derleyicinin tür çıkarıcısı ve otomatik genelleştirme mekanizmaları tarafından genel olduğu örtülü olarak çıkarılana kadar, kodunuzu genel yapmak F# ile basit olabilir.

Syntax

// Explicitly generic function.
let function-name<type-parameters> parameter-list =
function-body

// Explicitly generic method.
[ static ] member object-identifier.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

Açıklamalar

Açıkça genel bir işlevin veya türün bildirimi, işlev veya tür adının ardından açılı ayraçlar içinde tür parametrelerinin belirtimi (ve kullanımı) dışında genel olmayan bir işlevin veya türün bildirimine çok benzer.

Bildirim genellikle örtülü olarak geneldir. Bir işlev veya tür oluşturmak için kullanılan her parametrenin türünü tam olarak belirtmezseniz, derleyici her parametrenin, değerin ve değişkenin türünü, yazmakta olduğu koddan çıkarım yapmaya çalışır. Daha fazla bilgi için bkz. Tür Çıkarlığı. Tür veya işlevinizin kodu aksi takdirde parametre türlerini kısıtlamayacaksa, işlev veya tür örtülü olarak geneldir. Bu işlem otomatik genelleştirme olarak adlandırılmıştır. Otomatik genelleştirmenin bazı sınırları vardır. Örneğin, F# derleyicisi genel bir yapı için türleri çıkaramazsa, derleyici değer kısıtlaması olarak adlandırılan kısıtlamaya başvuran bir hata raporlar. Bu durumda bazı tür ek açıklamaları eklemeniz gerekir. Otomatik genelleştirme ve değer kısıtlaması ve kodunuzu sorunu çözmek için değiştirme hakkında daha fazla bilgi için bkz. Otomatik Genelleştirme.

Önceki söz dizimsinde, tür parametreleri bilinmeyen türleri temsil eden parametrelerin virgülle ayrılmış bir listesidir. Her biri tek tırnak işaretiyle başlar ve isteğe bağlı olarak bu tür parametresi için kullanılmaktadır. Çeşitli türlerde kısıtlama yan tümceleri ve kısıtlamalar hakkında diğer bilgiler için bkz. Kısıtlamalar.

Sözdiziminde tür tanımı, genel olmayan bir türün tür tanımıyla aynıdır. Bir sınıf türü için oluşturucu parametrelerini, isteğe bağlı yan tümcesini, eşit sembolünü, kayıt alanlarını, yan tümcesini, ayrımlı bir birlikteliğe ilişkin seçimleri ve bağlamaları, üye tanımlarını ve genel olmayan tür tanımında izin verilen diğer her şeyi as inherit let do içerir.

Diğer söz dizimi öğeleri, genel olmayan işlevler ve türlerle aynıdır. Örneğin, nesne tanımlayıcısı, içeren nesnenin kendisini temsil eden bir tanımlayıcıdır.

Özellikler, alanlar ve oluşturucular kapsayan türden daha genel olamaz. Ayrıca, bir modülde değerler genel olamaz.

Örtülü Olarak Genel Yapılar

F# derleyicisi kodundaki türleri çıkartırsa, genel olarak genel olan herhangi bir işlevi otomatik olarak davranır. Parametre türü gibi bir türü açıkça belirtirsiniz, otomatik genelleştirmeyi önlersiniz.

Aşağıdaki kod örneğinde, ne genel olarak ne de parametreleri açıkça genel olarak makeList bildirilene rağmen geneldir.

let makeList a b =
    [a; b]

İşlevin imzası olarak 'a -> 'a -> 'a list doğrular. Bu a b örnekteki ve ifadeleri aynı türe sahip olarak yorumlandırıldı. Bunun nedeni, bunların bir listeye birlikte dahil olması ve bir listenin tüm öğelerinin aynı türde olmasıdır.

Ayrıca, bir parametre türünün genel tür parametresi olduğunu belirtmek için bir tür ek açıklamasında tek tırnak işareti söz dizimi kullanarak bir işlevi genel hale de ebilirsiniz. Aşağıdaki kodda, parametreleri tür parametreleri olarak bu function1 şekilde bildirildiklerine göre geneldir.

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

Açıkça Genel Yapılar

Ayrıca, tür parametrelerini açılı ayraçlar () ile açıkça bildirerek de işlevi genel hale <type-parameter> dönüştürün. Aşağıdaki kodda bu gösterilir.

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

Genel Yapıları Kullanma

Genel işlevleri veya yöntemleri kullanırken, tür bağımsız değişkenlerini belirtmeniz gerekmebilirsiniz. Derleyici, uygun tür bağımsız değişkenlerini çıkarımk için tür çıkarıcısı kullanır. Belirsizlik devam ediyorsa, birden çok tür bağımsız değişkenlerini virgülle ayırarak açılı ayraç içinde tür bağımsız değişkenleri sebilirsiniz.

Aşağıdaki kod, önceki bölümlerde tanımlanan işlevlerin kullanımını gösterir.

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

Tür Bağımsız Değişkenleri olarak joker karakterler

Derleyici tarafından bir tür bağımsız değişkeninin belirtnmesi için, adlandırılmış tür bağımsız değişkeni yerine alt çizgi veya joker karakter simgesini ( _ ) kullanabilirsiniz. Bu, aşağıdaki kodda gösterilmiştir.

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

Genel Türlerde ve İşlevlerde Kısıtlamalar

Genel tür veya işlev tanımında yalnızca genel tür parametresinde kullanılabilir olduğu bilinen yapıları kullanabilirsiniz. Derleme zamanında işlev ve yöntem çağrılarının doğrulanması için bu gereklidir. Tür parametrelerinizi açıkça bildirerek, derleyiciye belirli yöntemlerin ve işlevlerin kullanılabilir olduğunu bildirmek için genel tür parametresine açık bir kısıtlama uygulayabilirsiniz. Ancak, F# derleyicisine genel parametre türlerinizi çıkartırsanız, sizin için uygun kısıtlamaları belirler. Daha fazla bilgi için bkz. Kısıtlamalar.

Statik Olarak Çözümlenmiş Tür Parametreleri

F# programlarında kullanılmaktadır iki tür parametre vardır. Birincisi, önceki bölümlerde açıklanan türe göre genel tür parametreleridir. Bu ilk tür parametresi, Visual Basic ve C# gibi dillerde kullanılan genel tür parametrelerine eşdeğerdir. Başka bir tür parametresi F# türüne özgü ve statik olarak çözümlenmiş tür parametresi olarak adlandırılır. Bu yapılar hakkında bilgi için bkz. Statik Olarak Çözümlenmiş Tür Parametreleri.

Ö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

Ayrıca bkz.

• Dil Başvurusu
• Türler
• Statik Olarak Çözümlenmiş Tür Parametreleri
• Genel Türler
• Otomatik Genelleştirme
• Kısıtlamalar