F# 10'daki yenilikler

F# 10 size F# dili, FSharp.Core kitaplığı ve araç geliştirmeleri getirir. Bu sürüm, günlük kodunuzu daha okunaklı ve sağlam hale getiren küçük ama anlamlı iyileştirmelerle netlik, tutarlılık ve performans odaklı bir iyileştirme sürümüdür. F# 10 , .NET 10 ve Visual Studio 2026 ile birlikte sağlanır.

En son .NET SDK'sını .NET indirmeleri sayfasından indirebilirsiniz.

Get started

F# 10 tüm .NET Core dağıtımlarında ve Visual Studio araçlarında kullanılabilir. Daha fazla bilgi için bkz. F# kullanmaya başlama.

Kapsamlı uyarı gizleme

Artık yeni #warnon yönergeyi kullanarak kodunuzun belirli bölümlerindeki uyarıları gizleyebilirsiniz. Bu, hangi uyarıların nereye uygulanacağı konusunda size kesin denetim sağlamak için mevcut #nowarn yönergeyle eşlenir.

Daha önce kullandığınızda #nowarn, dosyanın geri kalanı için bir uyarı devre dışı bırakılabilir ve bu da başka bir yerde geçerli sorunları bastırabilirdi. Motive edici bir örneğe bakalım:

// We know f is never called with None.
let f (Some a) =    // creates warning 25, which we want to suppress
    // 2000 loc, where the incomplete match warning is beneficial

İşlev tanımının üzerine eklerseniz #nowarn 25 , dosyanın geri kalanı için FS0025'i devre dışı bırakır.

F# 10 ile artık uyarının tam olarak gizlenmesini istediğiniz bölümü işaretleyebilirsiniz:

#nowarn 25
let f (Some x) =    // FS0025 suppressed
#warnon 25
    // FS0025 enabled again

Buna karşılık, bir uyarı genel olarak devre dışı bırakılırsa (örneğin, derleyici bayrağı aracılığıyla), bunu ile #warnonyerel olarak etkinleştirebilirsiniz. Bu yönerge, uyumlu bir #nowarn bulunana kadar veya dosyanın sonuna kadar geçerli olacaktır.

Önemli uyumluluk notları:

Bu özellik, yönergelerin tutarlılığını #nowarn/#warnon geliştiren çeşitli değişiklikler içerir. Bunlar uyumsuzluk yaratan değişikliklerdir:

• Derleyici artık çok satırlı ve boş uyarı yönergelerine izin vermemektedir.
• Derleyici artık # ve nowarn arasında boşluklara izin vermez.
• Uyarı numaraları için üç tırnaklı, ilişkilendirilmiş veya ayrıntılı dizeler kullanamazsınız.

Betik davranışı da değişti. Daha önce, betikte herhangi bir yere #nowarn yönergesi eklediğinizde, bu tüm derlemeye uygulanıyordu. Artık betiklerdeki davranışı, yalnızca dosyanın sonuna kadar veya buna karşılık gelen .fsbir uygulayarak dosyalardaki #warnon ile eşleşir.

Bu özellik RFC FS-1146 uygular.

Otomatik özellik erişimcilerinde erişim değiştiricileri

Nesne odaklı programlamada yaygın olarak kullanılan bir desen, genel olarak okunabilir ancak özel olarak değiştirilebilir durum oluşturmaktır. F# 10'dan önce, bunu başarmak için açık özellik sözdizimi ve arka plan değişkenleri (gerçek özellik değerlerini depolayan gizli değişkenler) kullanmanız gerekiyordu; bu da yinelenen kod eklenmesine neden oluyordu.

type Ledger() =
    [<DefaultValue>] val mutable private _Balance: decimal
    member this.Balance with public get() = this._Balance and private set v = this._Balance <- v

F# 10 ile artık tek tek özellik erişimcilerine farklı erişim değiştiricileri uygulayabilirsiniz. Bu, bir özelliğin alıcısı ve ayarlayıcısı için farklı erişim düzeyleri belirtmenize olanak sağlayarak deseni çok daha basit hale getirir:

type Ledger() =
    member val Balance = 0m with public get, private set

Erişim değiştiriciyi özellik adından önce (her iki erişimciye de uygulanır) veya ayrı ayrı erişimcilerin önüne yerleştirebilirsiniz, ancak her ikisini aynı anda yerleştiremezsiniz.

Bu özelliğin imza (.fsi) dosyalarına genişletilmediğini unutmayın. Ledger örneği için yukarıdaki doğru imza şöyledir:

type Ledger() =
    member Balance : decimal
    member private Balance : decimal with set

Bu özellik RFC FS-1141'i uygular.

ValueOption isteğe bağlı parametreler

Artık ValueOption<'T> için yapı tabanlı bir gösterim kullanabilirsiniz. [<Struct>] özniteliğini isteğe bağlı bir parametreye uyguladığınızda, derleyici option türünü başvuru tabanlı ValueOption<'T> türü yerine kullanır. Bu, performans açısından kritik kodda yararlı olan seçenek sarmalayıcısı için yığın ayırmalarını (çöp toplama gerektiren yönetilen yığında ayrılan bellek) önler.

Daha önce F# parametresi olmadığında bile isteğe bağlı parametreler için her zaman yığın ayrılmış option türünü kullanıyordu:

// Prior to F# 10: always uses reference option
type X() =
    static member M(?x : string) =
        match x with
        | Some v -> printfn "Some %s" v
        | None -> printfn "None"

F# 10'da, yapı destekli ValueOption özelliğini kullanmak için [<Struct>] özniteliğini kullanabilirsiniz:

type X() =
    static member M([<Struct>] ?x : string) =
        match x with
        | ValueSome v -> printfn "ValueSome %s" v
        | ValueNone -> printfn "ValueNone"

Bu, bağımsız değişken olmadığında yığın ayırmalarını ortadan kaldırır ve bu da performans açısından kritik kodda faydalıdır.

Ayırma basıncının önemli olduğu küçük değerler veya sık yapılan türler için bu yapı tabanlı seçeneği belirleyin. Mevcut desen eşleştirme yardımcılarına güveniyorsanız, başvuru semantiğine ihtiyaç duyduğunuzda veya performans farkı göz ardı edilebilir olduğunda varsayılan başvuru tabanlı option olanı kullanın. Bu özellik, zaten destekleyen ValueOptiondiğer F# dil yapıları ile eşliği güçlendirir.

Hesaplama ifadelerinde kuyruk çağrısı desteği

F# 10, kuyruk çağrısı optimizasyonlarını hesaplama ifadeleri için ekler. Hesaplama-ifade oluşturucuları artık özel yöntemler uygulayarak bu iyileştirmeleri kabul edebilir.

Derleyici hesaplama ifadelerini normal F# koduna (desugaring adlı bir işlem) çevirdiğinde, , return!veya yield! gibi do!bir ifadenin kuyruk konumunda ne zaman göründüğünü tanır. Oluşturucunuz aşağıdaki yöntemleri sağlıyorsa, derleyici bu çağrıları iyileştirilmiş giriş noktalarına yönlendirir:

• ReturnFromFinal - return! için çağrılır (olmaması durumunda ReturnFrom kullanılır)
• YieldFromFinal - kuyruk yield! için çağrılır (yoksa geri YieldFrom döner)
• Terminal do! için, derleyici ReturnFromFinal ve daha sonra YieldFromFinal tercih eder, normal Bind yoluna geri dönmeden önce.

Bu *Final üyeler isteğe bağlıdır ve yalnızca iyileştirmeyi etkinleştirmek için mevcuttur. Bu üyeleri sunmayan oluşturucular, mevcut anlamlarını olduğu gibi korur.

Örneğin:

coroutine {
    yield! subRoutine() // tail position -> YieldFromFinal if available
}

Ancak, kuyruk olmayan bir konumda:

coroutine {
    try
        yield! subRoutine() // not tail -> normal YieldFrom
    finally ()
}

Önemli uyumluluk notu:

Bir hesaplama ifadesi oluşturucusu bu adlara sahip üyeleri zaten tanımlıyorsa bu değişiklik bozulabilir. Çoğu durumda, var olan oluşturucular F# 10 ile derlendiğinde değişiklik yapmadan çalışmaya devam eder. Eski derleyiciler yeni *Final yöntemleri yoksayar, bu nedenle önceki derleyici sürümleriyle uyumlu kalması gereken oluşturucular derleyicinin bu yöntemleri çağıracağını varsaymamalıdır.

Bu özellik RFC FS-1330 uygular.

Parantez olmadan hesaplama ifadelerinde yazılan bağlamalar

F# 10, hesaplama ifadesi bağlamalarına tür ek açıklamaları eklerken parantez gereksinimini kaldırır. Artık let!, use! ve and! bağlamalarına, normal let bağlamalarla aynı söz dizimini kullanarak tür ek açıklamaları ekleyebilirsiniz.

Daha önce, tür ek açıklamaları için parantez kullanmanız gerekiyordu:

async {
    let! (a: int) = fetchA()
    and! (b: int) = fetchB()
    use! (d: MyDisposable) = acquireAsync()
    return a + b
}

F# 10'da, parantez olmadan tür anotasyonları yazabilirsiniz.

async {
    let! a: int = fetchA()
    and! b: int = fetchB()
    use! d: MyDisposable = acquireAsync()
    return a + b
}

use! bağlamalarında _'ye izin ver

Artık hesaplama ifadeleri içerisindeki use! bağlamalarında _ atma desenini kullanabilirsiniz. Bu, use!'ün davranışını normal use bağlamalarla uyumlu hale getirir.

Daha önce, derleyici bağlamalardaki use! iptal desenini reddederek geçici tanımlayıcılar oluşturmanızı gerektirdi.

counterDisposable {
    use! _ignored = new Disposable()
    // logic
}

F# 10'da doğrudan "discard pattern"ı kullanabilirsiniz.

counterDisposable {
    use! _ = new Disposable()
    // logic
}

Bu, değerleri yalnızca yaşam süresi yönetimi için gerekli olan eşzamansız kaynak bağlama sırasında amacı açıklar.

Türlerdeki sözde iç içe modülleri reddetme

Derleyici şimdi bir tür tanımının içine aynı yapısal düzeyde girintili bir module bildirim yerleştirdiğinizde bir hata oluşturur. Bu, türlerdeki yanıltıcı modül yerleşimini reddetmek için yapısal doğrulamayı sıkılaştırır.

Daha önce, derleyici tür tanımları içinde girintili bildirimleri kabul etti module , ancak aslında bu modülleri türün içine iç içe yerleştirme yerine türün eşdüzeyleri olarak oluşturmuştur:

type U =
    | A
    | B
    module M = // Silently created a sibling module, not nested
        let f () = ()

F# 10 ile bu düzen FS0058 hatasını tetikler ve uygun modül yerleşimi ile amacınızı netleştirmeye zorlar:

type U =
    | A
    | B

module M =
    let f () = ()

Atlanan seq için kullanımdan kaldırma uyarısı

Derleyici artık seq oluşturucuyu atlayan çıplak dizi ifadeleri hakkında sizi uyarır. "{ 1..10 } gibi çıplak aralık ayraçları kullandığınızda, size seq { ... } biçimini açıkça kullanmanız için teşvik eden bir kullanımdan kaldırma uyarısı görürsünüz."

Geçmişte, F# anahtar sözcüğünü atladığınız seq özel bir "dizi kavrama lite" söz dizimine izin verilebiliyor:

{ 1..10 } |> List.ofSeq  // implicit sequence, warning FS3873 in F# 10

F# 10'da derleyici bu desen hakkında uyarır ve açık formu teşvik eder:

seq { 1..10 } |> List.ofSeq

Bu şu anda bir uyarıdır, hata değildir ve kod tabanınızı güncelleştirmeniz için size zaman verir. tr-TR: Bu uyarıyı bastırmak istiyorsanız, NoWarn özelliğini proje dosyanızda veya #nowarn yönergenizde yerel olarak kullanın ve uyarı numarasını belirtin: 3873.

Açık seq form, kod netliğini ve diğer hesaplama ifadeleriyle tutarlılığı geliştirir. F# uygulamasının gelecekteki sürümleri bunu bir hataya neden olabilir, bu nedenle kodunuzu güncelleştirirken açık söz dizimini benimsemenizi öneririz.

Bu özellik RFC FS-1033'i uygular.

Öznitelik hedefi uygulama zorlaması

F# 10, tüm dil yapılarında öznitelik hedef doğrulamayı zorlar. Derleyici artık özniteliklerin yalnızca hedeflenen hedeflerine uygulandığını doğrulayarak, atanmış değerler, fonksiyonlar, birleşim durumları, örtük oluşturucular, yapılar ve sınıflar arasında AttributeTargets denetimini gerçekleştirir.

Daha önce, derleyici uyumsuz hedeflere öznitelikleri yanlış uygulamanıza sessizce izin verdi. İşlev olarak tanımlamayı unuttuğunuzda () test özniteliklerinin dikkate alınmaması gibi ince hatalara neden oldu.

[<Fact>]
let ``this is not a function`` = // Silently ignored in F# 9, not a test!
    Assert.True(false)

F# 10'da, derleyici öznitelik hedeflerini zorlar ve öznitelikler yanlış uygulandığında bir uyarı oluşturur:

[<Fact>]
//^^^^ - warning FS0842: This attribute cannot be applied to property, field, return value. Valid targets are: method
let ``this is not a function`` =
    Assert.True(false)

Önemli uyumluluk notu:

Bu, kod tabanınızda daha önce sessiz olan sorunları ortaya çıkarabilecek önemli bir değişikliktir. Erken hatalar test bulma sorunlarını önler ve çözümleyiciler ve dekoratörler gibi özniteliklerin amaçlandığı gibi etkin olmasını sağlar.

Görev ifadelerinde and! için destek

Artık and! kullanarak birden çok görevi eşzamanlı olarak bekleyebilirsiniz. Kullanmak task , özellikle C# ile birlikte çalışabilirliğe ihtiyacınız olduğunda F# dilinde zaman uyumsuz iş akışlarıyla çalışmanın popüler bir yoludur. Ancak şimdiye kadar, bir hesaplama ifadesinde birden çok görevi eşzamanlı olarak beklemenin kısa bir yolu yoktu.

Belki de hesaplamaları sıralı olarak bekleyen bir kodla başladınız:

// Awaiting sequentially
task {
    let! a = fetchA()
    let! b = fetchB()
    return combineAB a b
}

Daha sonra bunları eşzamanlı olarak beklemek için değiştirmek isterseniz, genellikle Task.WhenAll kullanırsınız.

// Use explicit Task combinator to await concurrently
task {
    let ta = fetchA()
    let tb = fetchB()
    let! results = Task.WhenAll([| ta; tb |])
    return combineAB ta.Result tb.Result
}

F# 10'da daha idiyomatik bir yaklaşım için kullanabilirsiniz and! :

task {
    let! a = fetchA()
    and! b = fetchB()
    return combineAB a b
}

Bu, eşzamanlı sürümün semantiğini sıralı sürümün basitliğiyle birleştirir.

Bu özellik F# dil önerisi #1363'i uygular ve kitaplığa FSharp.Core ek olarak uygulanır. Çoğu proje, bir sürümü FSharp.Core açıkça sabitlemedikleri sürece en son sürümünü derleyiciden otomatik olarak alır. Bu durumda, bu özelliği kullanmak için güncelleştirmeniz gerekir.

Varsayılan olarak daha iyi kırpma

F# 10, F# derlemelerini küçülterek uzun süredir devam eden bir pürüzü kaldırır. Kırpma, boyutunu küçültmek için yayımlanmış uygulamanızdan kullanılmayan kodu kaldırma işlemidir. Artık derleyicinin kullandığı ancak uygulamanızın çalışma zamanında gerekmeyen büyük F# meta veri kaynak bloblarını (imza ve iyileştirme verileri) çıkarmak için bir ILLink.Substitutions.xml dosyasını elle yönetmeniz gerekmiyor.

Kırpma etkin olduğunda (PublishTrimmed=true) yayımladığınızda, F# derlemesi artık otomatik olarak yalnızca araçlarla ilgili F# kaynaklarını hedefleyen gömülü bir yer değiştirme dosyası oluşturur.

Daha önce meta verileri silmek için bu dosyayı el ile tutmanız gerekiyordu. Bu, bakım yükünü de ekledi ve unutması kolay oldu.

Sonuç olarak, varsayılan olarak daha küçük çıkış, daha az yinelenen kodun bakımı ve daha az bakım riski ortaya çıkar. Tam el ile denetime ihtiyacınız varsa kendi değiştirme dosyanızı da ekleyebilirsiniz. özelliğiyle <DisableILLinkSubstitutions>false</DisableILLinkSubstitutions> otomatik oluşturmayı kapatabilirsiniz.

Önizlemede paralel derleme

Derleme sürelerini kısaltmak isteyen F# kullanıcıları için heyecan verici bir güncelleştirme: paralel derleme özellikleri dengeleniyor. .NET 10'dan başlayarak üç özellik vardır: graf tabanlı tür denetimi, paralel IL kodu oluşturma ve paralel iyileştirme, proje özelliği altında ParallelCompilation birlikte gruplandırılır.

F# 10, kullanan LangVersion=Previewprojeler için bu ayarı varsayılan olarak etkinleştirir. Bunu .NET 11'deki tüm projeler için etkinleştirmeyi planlıyoruz.

Bir deneyin ve derlemenizin hızlanıp hızlanmadığını görün. F# 10'da paralel derlemeyi etkinleştirmek için:

<PropertyGroup>
    <ParallelCompilation>true</ParallelCompilation>
    <Deterministic>false</Deterministic> <!-- Note: deterministic builds don't get the benefits of parallel compilation -->
</PropertyGroup>

Diğer önizleme özelliklerinden yararlanmaya devam ederken vazgeçmek istiyorsanız, ParallelCompilation ifadesini false olarak ayarlayın.

<PropertyGroup>
    <LangVersion>Preview</LangVersion>
    <ParallelCompilation>false</ParallelCompilation>
</PropertyGroup>

Paralel derleme, birden çok dosya ve bağımlılık içeren projeler için derleme sürelerini önemli ölçüde azaltabilir.

Tür kapsama cache

Derleyici artık tür çıkarımını hızlandırmak ve özellikle karmaşık tür hiyerarşileriyle çalışırken IDE performansını artırmak için tür ilişkisi denetimlerini önbelleğe alır. Derleyici, önceki alt işlem denetimlerinin sonuçlarını depolayıp yeniden kullanarak, daha önce derlemeyi ve IntelliSense'i yavaşlatan gereksiz hesaplamalardan kaçınır.

Önbelleği yönetme:

Çoğu durumda, tür alt işlem önbelleği herhangi bir yapılandırma olmadan performansı geliştirir. Ancak, bellek ayak izinin artması veya CPU kullanımının artmasıyla karşılaşırsanız (önbellek bakım çalışanları nedeniyle), önbellek davranışını ayarlayabilirsiniz:

• Önbelleği tamamen devre dışı bırakmak için proje dosyanızda F# 9 davranışına geri dönecek şekilde ayarlayın <LangVersion>9</LangVersion> .
• Zaman uyumsuz önbellek çıkarma özelliğini (iş parçacığı baskısını artıran) kapatmak ve bunun yerine zaman uyumlu çıkarma kullanmak için ortam değişkenini FSharp_CacheEvictionImmediate=1 ayarlayın.