F# 6'daki yeniler

F# 6, F# diline ve diline çeşitli geliştirmeler F# Etkileşimli. .NET 6 ile yayınlandı.

.NET indirmeleri sayfasından en son .NET SDK'larını indirebilirsiniz.

başlarken

F# 6, tüm .NET Core dağıtımlarında ve Visual Studio kullanılabilir. Daha fazla bilgi için bkz. F# Kullanmaya başlayın ile ilgili bilgi.

görev {...}

F# 6, F# kodunda .NET görevleri yazma için yerel destek içerir. Örneğin, oluşturmak için aşağıdaki F# kodunu göz önünde bulundurabilirsiniz. NET ile uyumlu görev:

let readFilesTask (path1, path2) =
   async {
        let! bytes1 = File.ReadAllBytesAsync(path1) |> Async.AwaitTask
        let! bytes2 = File.ReadAllBytesAsync(path2) |> Async.AwaitTask
        return Array.append bytes1 bytes2
   } |> Async.StartAsTask

F# 6 kullanılarak bu kod aşağıdaki gibi yeniden yazılabilir.

let readFilesTask (path1, path2) =
   task {
        let! bytes1 = File.ReadAllBytesAsync(path1)
        let! bytes2 = File.ReadAllBytesAsync(path2)
        return Array.append bytes1 bytes2
   }

F# 5 için görev desteği, mükemmel TaskBuilder.fs ve Ply kitaplıkları aracılığıyla kullanılabilir durumdadır. Kodu yerleşik de destekle geçirmek kolay bir işlem olabilir. Ancak bazı farklılıklar vardır: ad alanları ve tür çıkarlığı, yerleşik destekle bu kitaplıklar arasında biraz farklılık gösterir ve bazı ek ek açıklamalar gerekli olabilir. Gerekirse, açık olarak başvurursanız ve her dosyada doğru ad alanlarını açarsanız bu topluluk kitaplıklarını F# 6 ile kullanmaya devam edin.

kullanmak, task {…} kullanımına çok async {…} benzer. kullanmanın task {…} çeşitli avantajları async {…} vardır:

• performansı task {…} çok daha iyidir.
• için adımlama ve yığın izlemeleri hata task {…} ayıklaması daha iyidir.
• Görev bekleyabilen veya üreten .NET paketleriyle birlikte çalışma daha kolaydır.

hakkında bilgi sahibiysanız async {…} dikkat etmek gereken bazı farklılıklar vardır:

• task {…} görevi ilk await noktasına hemen yürütür.
• task {…} , bir iptal belirteci örtülü olarak yayılmaz.
• task {…} örtülü iptal denetimleri gerçekleştirmez.
• task {…} zaman uyumsuz tailcall'ları desteklemez. Başka bir anlama gelir ki, müdahalede geçen zaman uyumsuz beklemeler yoksa, tekrar tekrar kullanmak yığın return! .. taşmalarında neden olabilir.

Genel olarak, görevleri kullanan .NET kitaplıkları ile birlikte kullanıyorsanız ve zaman uyumsuz kod tailcalls veya örtülü iptal belirteci yayılmasını kullanmayacaksanız, yeni kodda fazla kullanmayı task {…} async {…} düşünebilirsiniz. Mevcut kodda, daha önce bahsedilen özelliklerine güvenmeytiğinizi emin olmak için kodunuzu gözden geçirmenizin ardından 'a task {…} geçmeniz async {…} gerekir.

Bu özellik F# RFC FS-1097'yi uygulamaya almaktadır.

ile daha basit dizinleme söz dizimi expr[idx]

F# 6, koleksiyonları expr[idx] dizinleme ve yalıtma söz dizimlerini sağlar.

F# 5'e kadar ve buna dahil, F# expr.[idx] dizinleme söz dizimi olarak kullanılmıştır. kullanımına izin verme, F# öğrenenlerden gelen yinelenen geri bildirimleri temel alarak veya nokta nota dizinleme kullanımının standart sektör uygulamalarından gereksiz bir ayrım olarak karşı karşıya olduğunu ilk kez expr[idx] görmektir.

Bu hataya neden olan bir değişiklik değildir çünkü varsayılan olarak kullanımına hiçbir uyarı expr.[idx] yaymaz. Ancak, kod açıklamalarını öneren bazı bilgilendirme iletileri yayımlar. İsteğe bağlı olarak daha fazla bilgi iletilerini de etkin durumda abilirsiniz. Örneğin, bildirimin kullanımlarını raporlamaya başlamak için isteğe bağlı bir bilgilendirme uyarısı ( /warnon:3566 ) expr.[idx] etkinleştirebilirsiniz. Daha fazla bilgi için bkz. Indexer Notation.

Yeni kodda, dizinleme söz dizimi olarak expr[idx] sistematik kullanımını öneririz.

Bu özellik F# RFC FS-1110 'yi uygulamaya almaktadır.

Kısmi etkin desenler için yapı gösterimleri

F# 6, "etkin desenler" özelliğini kısmi etkin desenler için isteğe bağlı yapı gösterimleriyle zenginler. Bu, bir özniteliği kullanarak kısmi etkin deseni bir değer seçeneğine dönüş yapmak üzere sınırlamak için sağlar:

[<return: Struct>]
let (|Int|_|) str =
   match System.Int32.TryParse(str) with
   | true, int -> ValueSome(int)
   | _ -> ValueNone

özniteliğinin kullanımı gereklidir. Kullanım sitelerinde kod değişmez. Sonuçta ayırmalar azaltıldı.

Bu özellik, F# RFC FS-1039 'yi uygulamaya almaktadır.

Hesaplama ifadelerinde aşırı yüklenmiş özel işlemler

F# 6, varsayılan uygulamalarıyla arabirimleri tüketmenizi sağlar.

Aşağıdaki hesaplama ifadesi oluşturucusu kullanımını göz önünde content bulundurarak:

let mem = new System.IO.MemoryStream("Stream"B)
let content = ContentBuilder()
let ceResult =
    content {
        body "Name"
        body (ArraySegment<_>("Email"B, 0, 5))
        body "Password"B 2 4
        body "BYTES"B
        body mem
        body "Description" "of" "content"
    }

Burada body özel işlem, farklı türlerde farklı sayıda bağımsız değişken alır. Bu, aşırı yüklemeyi kullanan aşağıdaki oluşturucu uygulaması tarafından de destekler:

type Content = ArraySegment<byte> list

type ContentBuilder() =
    member _.Run(c: Content) =
        let crlf = "\r\n"B
        [|for part in List.rev c do
            yield! part.Array[part.Offset..(part.Count+part.Offset-1)]
            yield! crlf |]

    member _.Yield(_) = []

    [<CustomOperation("body")>]
    member _.Body(c: Content, segment: ArraySegment<byte>) =
        segment::c

    [<CustomOperation("body")>]
    member _.Body(c: Content, bytes: byte[]) =
        ArraySegment<byte>(bytes, 0, bytes.Length)::c

    [<CustomOperation("body")>]
    member _.Body(c: Content, bytes: byte[], offset, count) =
        ArraySegment<byte>(bytes, offset, count)::c

    [<CustomOperation("body")>]
    member _.Body(c: Content, content: System.IO.Stream) =
        let mem = new System.IO.MemoryStream()
        content.CopyTo(mem)
        let bytes = mem.ToArray()
        ArraySegment<byte>(bytes, 0, bytes.Length)::c

    [<CustomOperation("body")>]
    member _.Body(c: Content, [<ParamArray>] contents: string[]) =
        List.rev [for c in contents -> let b = Text.Encoding.ASCII.GetBytes c in ArraySegment<_>(b,0,b.Length)] @ c

Bu özellik F# RFC FS-1056 'yi uygulamaya almaktadır.

"as" desenleri

F# 6'da bir desenin sağ as tarafı artık bir desen olabilir. Bir tür testi girişe daha güçlü bir tür verdiği zaman bu önemlidir. Örneğin, aşağıdaki kodu düşünün:

type Pair = Pair of int * int

let analyzeObject (input: obj) =
    match input with
    | :? (int * int) as (x, y) -> printfn $"A tuple: {x}, {y}"
    | :? Pair as Pair (x, y) -> printfn $"A DU: {x}, {y}"
    | _ -> printfn "Nope"

let input = box (1, 2)

Her desende giriş nesnesi tür test edilir. Desenin sağ tarafında artık daha güçlü türde nesneyle eş hale geldikçe daha fazla as desene izin verilir.

Bu özellik F# RFC FS-1105'i uygulamaya almaktadır.

Girintileme söz dizimi düzeltmeleri

F# 6, girintiyi kullanan söz dizimi kullanımında bir dizi tutarsızlığı ve sınırlamayı kaldırır. Bkz. RFC FS-1108. Bu, F# 4.0'dan bu yana F# kullanıcıları tarafından vurgulanan 10 önemli sorunu çözer.

Örneğin, F# 5'te aşağıdaki koda izin verildi:

let c = (
    printfn "aaaa"
    printfn "bbbb"
)

Ancak, aşağıdaki koda izin verilmedi (bir uyarı üretti):

let c = [
    1
    2
]

F# 6'da her ikisine de izin verilir. Bu, F# ile ilgili daha basit ve öğrenmeyi kolaylaştırır. F# topluluğu katkıda bulunanı Had üçgen Tang, özelliğin dikkat çekici ve yüksek oranda değerli sistematik testi de dahil olmak üzere bu noktada yol açtı.

Bu özellik F# RFC FS-1108'i uygulamaya almaktadır.

Ek örtülü dönüştürmeler

F# 6'da, RFC FS-1093'teaçıklandığı gibi ek "örtülü" ve "türe yönelik" dönüştürmeler için destek etkinleştirildi.

Bu değişiklik üç avantaj getirir:

1. Daha az açık yayın gereklidir
2. Daha az açık tamsayı dönüştürmesi gerekir
3. için birinci sınıf destek. NET stili örtülü dönüştürmeler eklendi

Bu özellik F# RFC FS-1093'ü uygulamaya almaktadır.

Ek örtülü yukarı yayın dönüştürmeleri

F# 6 ek örtülü yukarı yayın dönüştürmeleri uygulanır. Örneğin F# 5 ve önceki sürümlerde, bir tür ek açıklaması mevcut olsa bile ifadelerin farklı dallarda farklı alt türlere sahip olduğu bir işlev uygulanırken dönüş ifadesi için yayına gerek duyuldu. Aşağıdaki F# 5 kodunu düşünün:

open System
open System.IO

let findInputSource () : TextReader =
    if DateTime.Now.DayOfWeek = DayOfWeek.Monday then
        // On Monday a TextReader
        Console.In
    else
        // On other days a StreamReader
        File.OpenText("path.txt") :> TextReader

Burada koşullu işlem dalları ve sırasıyla ve her iki dalda da StreamReader türüne sahip olacak şekilde yukarı yayın TextReader StreamReader eklenmiştir. F# 6'da bu yayın artık otomatik olarak eklenir. Bu, kodun daha basit olduğu anlamına gelir:

let findInputSource () : TextReader =
    if DateTime.Now.DayOfWeek = DayOfWeek.Monday then
        // On Monday a TextReader
        Console.In
    else
        // On other days a StreamReader
        File.OpenText("path.txt")

İsteğe bağlı olarak, örtülü dönüştürmeler için isteğe bağlı uyarılar konusunda açıklandığı gibi ek bir örtülü yukarı yayın kullanılan her noktada uyarı /warnon:3388 göstermek için uyarıyı etkinleştirebileceksiniz.

Örtülü tamsayı dönüştürmeleri

F# 6'da, her iki tür de bilindiği zaman 32 bit tamsayılar 64 bit tamsayılara genişletir. Örneğin, tipik bir API şeklini düşünün:

type Tensor(…) =
    static member Create(sizes: seq<int64>) = Tensor(…)

F# 5'te, int64 için tamsayı değişmez değeri kullanılmalıdır:

Tensor.Create([100L; 10L; 10L])

veya

Tensor.Create([int64 100; int64 10; int64 10])

F# 6'da, hem kaynak hem de hedef türü tür çıkarı sırasında bilindiği zaman için için , için ve için int32 int64 int32 nativeint int32 double genişletilir. Bu nedenle, önceki örneklerde olduğu int32 gibi sabitler kullanılabilir:

Tensor.Create([100; 10; 10])

Bu değişiklike rağmen F# çoğu durumda sayısal türlerin açıkça genişletilen kullanımını kullanmaya devam eder. Örneğin, örtülü genişleme, veya gibi diğer sayısal türler için veya kaynağından veya kaynağı ya da hedef türü int8 int16 float32 float64 bilinmiyorsa geçerli değildir. Ayrıca, örtülü dönüştürmeler için isteğe bağlı uyarılar konusunda açıklandığı gibi, isteğe bağlı olarak, örtülü sayısal genişletilen her noktada bir uyarı /warnon:3389 göstermek için etkinleştirsiniz.

için birinci sınıf destek. NET stili örtülü dönüştürmeler

F# 6'da ,NET "op_Implicit" dönüştürmeleri, metotlar çağrılırken F# kodunda otomatik olarak uygulanır. Örneğin F# 5'te XML için XName.op_Implicit .NET API'leri ile çalışırken kullanmak gerekliydi:

open System.Xml.Linq
let purchaseOrder = XElement.Load("PurchaseOrder.xml")
let partNos = purchaseOrder.Descendants(XName.op_Implicit "Item")

F# 6'da, türler kaynak ifade ve hedef tür için kullanılabilir olduğunda dönüştürmeler bağımsız op_Implicit değişken ifadeleri için otomatik olarak uygulanır:

open System.Xml.Linq
let purchaseOrder = XElement.Load("PurchaseOrder.xml")
let partNos = purchaseOrder.Descendants("Item")

Örtülü dönüştürmeler için isteğe bağlı uyarılar konusunda açıklandığı gibi, isteğe bağlı olarak, örtülü sayısal genişletilen her noktada bir uyarı /warnon:3395 göstermek için etkinleştirin.

Örtülü dönüştürmeler için isteğe bağlı uyarılar

Türe yönelik ve örtülü dönüştürmeler, tür çıkarı ile kötü etkileşimde bulunarak daha zor anlaşılır kodlara yol açabilir. Bu nedenle, F# kodunda bu özelliğin kötüye kullanmaması için bazı risk azaltmaları vardır. İlk olarak, hem kaynak hem de hedef türü kesin olarak bilinmeli ve belirsizlik veya ek tür çıkarımları ortaya çıkar. İkinci olarak, varsayılan olarak bir uyarı açık olacak şekilde, örtülü dönüştürmelerin herhangi bir kullanımını rapor etmek için kabul uyarıları etkinleştirilebilir:

• /warnon:3388 (ek örtülü yukarı yayın)
• /warnon:3389 (örtülü sayısal genişle)
• /warnon:3391 (op_Implicit olmayan bağımsız değişkenlerde varsayılan olarak açıktır)
• /warnon:3395 (op_Implicit bağımsız değişkenlerde)

Takımınız tüm örtülü dönüştürme kullanımlarını yasaklamak istiyorsa , , ve /warnaserror:3388 de /warnaserror:3389 /warnaserror:3391 belirtesiniz. /warnaserror:3395

İkili sayılar için biçimlendirme

F# 6, %B ikili sayı biçimleri için kullanılabilir biçim belirleyicilere deseni ekler. Aşağıdaki F# kodunu düşünün:

printf "%o" 123
printf "%B" 123

Bu kod aşağıdaki çıkışı yazdırır:

173
1111011

Bu özellik, F# RFC FS-1100 'i uygulamaya almaktadır.

Kullanım bağlamaları üzerinde atmalar

F# 6 _ bir bağlamada kullanılmaya use izin verir, örneğin:

let doSomething () =
    use _ = System.IO.File.OpenText("input.txt")
    printfn "reading the file"

Bu özellik F# RFC FS-1102'yi uygulamaya almaktadır.

InlineIfLambda

F# derleyicisi, kodun altı çizili işlemini gerçekleştiren bir iyileştirici içerir. F# 6'da, kodun isteğe bağlı olarak, bir bağımsız değişkenin lambda işlevi olduğu belirlenirse, bu bağımsız değişkenin çağrı sitelerinde her zaman içinde olması gerektiğini belirtecek yeni bir bildirim özelliği ekledik.

Örneğin, bir diziyi çapraz iterateTwice geçiş yapmak için aşağıdaki işlevi göz önünde önünden alalım:

let inline iterateTwice ([<InlineIfLambda>] action) (array: 'T[]) =
    for j = 0 to array.Length-1 do
        action array[j]
    for j = 0 to array.Length-1 do
        action array[j]

Çağrı sitesi şu şekilde ise:

let arr = [| 1.. 100 |]
let mutable sum = 0
arr  |> iterateTwice (fun x ->
    sum <- sum + x)

Ardından, inlining ve diğer iyileştirmeler sonrasında kod şöyle olur:

let arr = [| 1.. 100 |]
let mutable sum = 0
for j = 0 to array.Length-1 do
    sum <- array[i] + x
for j = 0 to array.Length-1 do
    sum <- array[i] + x

Önceki F# sürümlerinden farklı olarak, bu iyileştirme söz konusu lambda ifadesinin boyutundan bağımsız olarak uygulanır. Bu özellik, döngü kaydı ve benzer dönüştürmeleri daha güvenilir bir şekilde uygulamak için de kullanılabilir.

Kodda bağımsız değişkenlerin çağrı sitelerinde lambda ifadelerine bağlı olmadığını belirtmek için bir kabul uyarısı ( varsayılan olarak /warnon:3517 kapalı) InlineIfLambda açık olabilir. Normal durumlarda bu uyarı etkinleştirilmemiş olmalıdır. Ancak, belirli türlerde yüksek performanslı programlamada, tüm kodun düz ve düz olduğundan emin olmak yararlı olabilir.

Bu özellik F# RFC FS-1098'i uygulamaya almaktadır.

Devam edilebilir kod

task {…}F# 6 desteği, sürdürme kodu RFC FS-1087 adlı bir temel üzerine kurulur. Devam edilebilir kod, birçok tür yüksek performanslı zaman uyumsuz ve verimli durum makinesi oluşturmak için kullanılan teknik bir özelliktir.

Ek koleksiyon işlevleri

FSharp.Core 6.0.0, çekirdek koleksiyon işlevlerine beş yeni işlem ekler. Bu işlevler:

• List/Array/Seq.insertAt
• List/Array/Seq.removeAt
• List/Array/Seq.updateAt
• List/Array/Seq.insertManyAt
• List/Array/Seq.removeManyAt

Bu işlevlerin hepsi, ilgili koleksiyon türü veya dizi üzerinde kopyalama ve güncelleştirme işlemleri gerçekleştirir. Bu işlem türü bir "işlevsel güncelleştirme" biçimidir. Bu işlevleri kullanma örnekleri için, list.insertAtgibi ilgili belgelere bakın.

Örneğin Elmish stilinde yazılmış basit bir "Todo List" uygulaması için modeli, iletiyi ve güncelleştirme mantığını düşünün. Burada kullanıcı uygulamayla etkileşime geçme, ileti oluşturma ve işlev bu iletileri işerek yeni update bir model oluşturma:

type Model =
    { ToDo: string list }

type Message =
    | InsertToDo of index: int * what: string
    | RemoveToDo of index: int
    | LoadedToDos of index: int * what: string list

let update (model: Model) (message: Message) =
    match message with
    | InsertToDo (index, what) ->
        { model with ToDo = model.ToDo |> List.insertAt index what }
    | RemoveToDo index ->
        { model with ToDo = model.ToDo |> List.removeAt index }
    | LoadedToDos (index, what) ->
        { model with ToDo = model.ToDo |> List.insertManyAt index what }

Bu yeni işlevlerle mantık net ve basittir ve yalnızca sabit verilere dayandırılabilir.

Bu özellik F# RFC FS-1113'ü uygulamaya almaktadır.

Eşlemede Anahtarlar ve Değerler var

FSharp.Core 6.0.0'da tür Map artık Anahtarlar ve Değerler özelliklerini destekliyor. Bu özellikler, temel alınan koleksiyonu kopyalamaz.

Bu özellik F# RFC FS-1113'te belgelenmiştir.

NativePtr için ek iç bilgiler

FSharp.Core 6.0.0, NativePtr modülüne yeni iç iç ekler:

• NativePtr.nullPtr
• NativePtr.isNullPtr
• NativePtr.initBlock
• NativePtr.clear
• NativePtr.copy
• NativePtr.copyBlock
• NativePtr.ofILSigPtr
• NativePtr.toILSigPtr

'daki diğer işlevlerde olduğu gibi, bu işlevler de altı çizilidir ve kullanılmadıkça NativePtr uyarıları /nowarn:9 gösterir. Bu işlevlerin kullanımı, unmanaged türleriyle sınırlıdır.

Bu özellik F# RFC FS-1109 içinde belgelenmiştir.

Birim ek açıklamalı ek sayısal türler

F# 6'da, aşağıdaki türler veya tür kısaltmaları artık ölçü birimi ek açıklamalarını destekler. Yeni eklemeler kalın olarak gösterilir:

Örneğin, imzasız bir tamsayıya aşağıdaki gibi açıklama sızabilirsiniz:

[<Measure>]
type days

let better_age = 3u<days>

Bu özellik F# RFC FS-1091'de belgelenmiş.

Nadiren kullanılan sembolik işleçler için bilgilendirme uyarıları

F# 6, F# 6 ve ötesinde , , ve kullanımını := ! incr normalleştiren yazılım decr kılavuzlarını ekler. Bu işleçlerin ve işlevlerin kullanımı, kodunuzun özelliğinin açık kullanımıyla değiştirilmesini istemek için bilgi iletileri Value üretir.

F# programlamada, başvuru hücreleri yığın tarafından ayrılan tarifeli yazmaçlar için kullanılabilir. Bunlar bazen yararlı olsa da modern F# kodlaması için nadiren ihtiyaç duyulsa da bunun let mutable yerine kullanılabilir. F# çekirdek kitaplığı, özellikle başvuru çağrılarını := ! içeren iki işleç ve iki işlev incr decr içerir. Bu işleçlerin varlığı, başvuru hücreleriniN F# programlaması için olması gerekenden daha merkezi hale geldi ve tüm F# programcılarının bu işleçleri bildi. Ayrıca işleci C# ve diğer dillerdeki işlemiyle kolayca karıştırılabiliyor ve bu da kodun çevirisinde küçük olabilecek hatalar ! not kaynağıdır.

Bu değişikliğin gerekçesi, F# programcılarının bilmek zorunda olduğu işleç sayısını azaltmak ve böylece F# 'yi yeni başlayanlar için basitleştirmektir.

Örneğin, aşağıdaki F# 5 kodunu düşünün:

let r = ref 0

let doSomething() =
    printfn "doing something”
    r := !r + 1

Birincisi, başvuru hücreleri modern F# kodlaması için nadiren gereklidir çünkü let mutable normalde bunun yerine kullanılabilir:

let mutable r = 0

let doSomething() =
    printfn "doing something”
    r <- r + 1

Başvuru hücreleri kullanıyorsanız F# 6, son satırı olarak değiştirmenizi isteyen ve başvuru hücrelerinin uygun kullanımıyla ilgili daha fazla rehbere bağlamanız gereken bir r.Value <- r.Value + 1 bilgilendirme uyarısı verir.

let r = ref 0

let doSomething() =
    printfn "doing something”
    r.Value <- r.Value + 1

Bu iletiler uyarı değildir; bunlar, IDE ve derleyici çıkışında gösterilen "bilgilendirme iletileridir". F# geriye dönük uyumlu olmaya devam ediyor.

Bu özellik F# RFC FS-1111'i uygulamaya almaktadır.

F# aracı: .NET 6, Visual Studio'da betik Visual Studio

Visual Studio'da bir F# Betiği ( ) açar veya yürütürsanız, betik varsayılan olarak 64 bit yürütme ile .NET 6 kullanılarak analiz edilir ve .fsx yürütülür. Bu işlevsellik, Visual Studio 2019'un sonraki yayınlarında önizlemededir ve artık varsayılan olarak etkindir.

Komut dosyası .NET Framework etkinleştirmek için Araçlar Seçenekleri > > F# Araçları'F# Etkileşimli. > .NET Core Betiği Kullan'ı false olarak ayarlayın ve ardından F# Etkileşimli başlatın. Bu ayar hem betik düzenlemeyi hem de betik yürütmeyi etkiler. Komut dosyası için 32 bit yürütmeyi .NET Framework için 64 bitlik F# Etkileşimli false olarak ayarlayın. .NET Core betiği için 32 bit seçeneği yoktur.

F# aracı: F# betiklerinin SDK sürümünü sabitleme

.NET SDK ayarıyla global.json dosyası içeren bir dizinde kullanarak bir betik yürütürseniz, betiği yürütmek ve düzenlemek için dotnet fsi listelenen .NET SDK sürümü kullanılır. Bu özellik, F# 5'in sonraki sürümlerinde kullanılabilir.

Örneğin, bir dizinde aşağıdaki global.json dosyasının .NET SDK sürüm ilkesi belirten bir betiği olduğunu varsayalım:

{
  "sdk": {
    "version": "5.0.200",
    "rollForward": "minor"
  }
}

Şimdi betiği kullanarak dotnet fsi yürütürsanız, bu dizinden SDK sürümüne saygı duyarız. Bu, betiklerinizi derlemek, analiz etmek ve yürütmek için kullanılan SDK'yı "kilitlemenize" olanak sağlayan güçlü bir özelliktir.

Betiğinizi hem IDE'Visual Studio hem de diğer IDE'lerde açıp düzenlerseniz, betiğinizi analiz etmek ve kontrol etmek için araç bu ayarı benimser. SDK bulunamasa geliştirme makinenize yüklemeniz gerekir.

Linux ve diğer Unix sistemlerinde, betiğin doğrudan yürütülmesi için bir dil sürümü belirtmek için bunu bir shebang ile birleştirin. için basit bir script.fsx shebang:

#!/usr/bin/env -S dotnet fsi

printfn "Hello, world"

Artık betik doğrudan ile script.fsx yürütülebilirsiniz. Bunu, varsayılan olmayan belirli bir dil sürümüyle birleştirin:

#!/usr/bin/env -S dotnet fsi --langversion:5.0

Eski özellikleri kaldırma

F# 2.0'dan bu yana, kullanım dışı olan bazı eski özelliklerde uzun süre verilen uyarılar vardır. Bu özellikleri F# 6'da kullanmak açıkça kullanmadıkça hata /langversion:5.0 verir. Hata vermeyen özellikler şunlardır:

• Sonek türü adı kullanan birden çok genel parametre, örneğin (int, int) Dictionary . Bu, F# 6'da hataya neden olur. Bunun yerine Dictionary<int,int> standart söz dizimi kullanılmalıdır.
• #indent "off". Bu bir hataya neden olur.
• x.(expr). Bu bir hataya neden olur.
• module M = struct … end . Bu bir hataya neden olur.
• ve girişlerinin *.ml *.mli kullanımı. Bu bir hataya neden olur.
• veya (*IF-CAML*) (*IF-OCAML*) kullanımı. Bu bir hataya neden olur.
• , land , lor lxor , , , lsl veya lsr asr infix işleçleri olarak kullanımı. Bunlar F# içinde sabit anahtar sözcüklerdir çünkü OCaml'de sonek anahtar sözcüklerdir ve FSharp.Core'da tanımlanmamıştır. Bu anahtar sözcükleri kullanmak artık bir uyarı gösterir.

Bu, F# RFC FS-1114'ü uygulamaya almaktadır.