F# 6'daki yenilikler

Makale
03/05/2024

F# 6, F# diline ve F# Etkileşimli'ye çeşitli geliştirmeler ekler. .NET 6 ile yayınlanır.

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

Kullanmaya başlayın

F# 6 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.

{...} görevi

F# 6, F# kodunda .NET görevleri yazmak için yerel destek içerir. Örneğin, oluşturmak için aşağıdaki F# kodunu göz önünde bulundurun. NET 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 mükemmel TaskBuilder.fs ve Ply kitaplıkları aracılığıyla görev desteği sağlandı. Kodu yerleşik desteğe geçirmek kolay olmalıdır. Ancak bazı farklılıklar vardır: ad alanları ve tür çıkarımı yerleşik destek ile bu kitaplıklar arasında biraz farklılık gösterir ve bazı ek tür ek açıklamaları gerekebilir. Gerekirse, bu topluluk kitaplıklarına açıkça başvuruda bulunursanız ve her dosyada doğru ad alanlarını açarsanız F# 6 ile bu topluluk kitaplıklarını kullanmaya devam edebilirsiniz.

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

ek yükü task {...} daha düşüktür ve büyük olasılıkla zaman uyumsuz çalışmanın hızla yürütüldüğü sık erişimli kod yollarındaki performansı artırır.
için adımlama ve yığın izlemelerinde task {…} hata ayıklamak daha iyidir.
Görevleri bekleyen veya üreten .NET paketleriyle birlikte çalışma daha kolaydır.

hakkında async {…}bilgi sahibiyseniz, dikkat etmeniz gereken bazı farklılıklar vardır:

task {…} görevi ilk bekleme noktasına hemen yürütür.
task {…} bir iptal belirtecini örtük olarak yaymaz.
task {…} örtük iptal denetimleri gerçekleştirmez.
task {…} zaman uyumsuz tailcall'ları desteklemez. Bu, zaman uyumsuz beklemelerin gecikmesi yoksa özyinelemeli olarak kullanmanın return! .. yığın taşmalarına neden olabileceği anlamına gelir.

Genel olarak, görevleri kullanan .NET kitaplıklarıyla birlikte kullanıyorsanız ve zaman uyumsuz kod tailcalls veya örtük iptal belirteci yayma kullanmıyorsanız, yeni kodda kullanmayı düşünmelisiniz task {…}async {…} . Mevcut kodda, daha önce bahsedilen özelliklerine task {…}async {…}güvenmediğinizden emin olmak için yalnızca kodunuzu gözden geçirdikten sonra geçiş yapmanız gerekir.

Bu özellik F# RFC FS-1097'i uygular.

ile daha basit dizin oluşturma söz dizimi `expr[idx]`

F# 6, koleksiyonları dizinleme ve dilimleme söz dizimine expr[idx] izin verir.

F# 5'e kadar ve dahil olmak üzere, F# dizin söz dizimi olarak kullanılmıştır expr.[idx] . kullanımına expr[idx] izin vermek, F# öğrenenlerden veya F# ile ilk kez noktalı gösterimi dizinleme kullanımının standart endüstri uygulamasından gereksiz bir ayrışma olarak karşımıza çıktığına ilişkin yinelenen geri bildirimlere dayanır.

Bu hataya neden olan bir değişiklik değildir, çünkü varsayılan olarak kullanımıyla expr.[idx]ilgili hiçbir uyarı gösterilmez. Ancak, kod açıklamalarını öneren bazı bilgilendirme iletileri yayılır. İsteğe bağlı olarak daha fazla bilgi iletilerini de etkinleştirebilirsiniz. Örneğin, gösterimin kullanımlarını raporlamaya başlamak için isteğe bağlı bir bilgilendirme uyarısını expr.[idx] (/warnon:3566) etkinleştirebilirsiniz. Daha fazla bilgi için bkz . Dizin Oluşturucu Gösterimi.

Yeni kodda, dizin oluşturma söz dizimi olarak sistematik olarak kullanılmasını expr[idx] öneririz.

Bu özellik F# RFC FS-1110 uygular.

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

F# 6, kısmi etkin desenler için isteğe bağlı yapı gösterimleriyle "etkin desenler" özelliğini genişletir. Bu, bir değer seçeneği döndürmek üzere kısmi etkin deseni kısıtlamak için bir öznitelik kullanmanıza olanak tanır:

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

özniteliğinin kullanılması gerekir. Kullanım sitelerinde kod değişmez. Net sonuç, ayırmaların azaltılmasıdır.

Bu özellik F# RFC FS-1039 uygular.

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

F# 6, aşırı yüklenmiş yöntemler üzerinde CustomOperationAttribute kullanmanıza olanak tanır.

Hesaplama ifadesi oluşturucusunun contentaşağıdaki kullanımını göz önünde bulundurun:

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"
    }

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

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 uygular.

"as" desenleri

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

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 desen örneğinde giriş nesnesi tür testi yapılır. Desenin sağ tarafının as artık daha güçlü türdeki nesneyle eşleşebilen başka bir desen olmasına izin verilir.

Bu özellik F# RFC FS-1105'i uygular.

Girinti söz dizimi düzeltmeleri

F# 6, girintiye duyarlı söz dizimi kullanımında bir dizi tutarsızlık 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 ikisinde de izin verilir. Bu, F# dilini daha basit ve daha kolay öğrenilir hale getirir. F# topluluk katkıda bulunanı Hadrian Tang , özelliğin dikkat çekici ve son derece değerli sistematik testi de dahil olmak üzere bu konuda öncülük etti.

Bu özellik F# RFC FS-1108'i uygular.

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

F# 6'da, RFC FS-1093'te açıklandığı gibi ek "örtük" ve "türe yönlendirilmiş" dönüştürmeler için desteği etkinleştirdik.

Bu değişiklik üç avantaj getirir:

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

Bu özellik F# RFC FS-1093 uygular.

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

F# 6, ek örtük yukarı yayın dönüştürmeleri uygular. Ö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 yukarı yayınlar gerekiyordu. Aşağıdaki F# 5 kodunu göz önünde bulundurun:

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 sırasıyla a TextReader ve StreamReader koşullu işleminin dalları ve her iki dalın da StreamReader türüne sahip olması için yukarı yayın eklenmiştir. F# 6'da bu yukarı yayınlar 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, /warnon:3388 örtük dönüştürmeler için isteğe bağlı uyarılar bölümünde açıklandığı gibi ek örtük bir yukarı yayının kullanıldığı her noktada uyarı gösterilmesi için uyarıyı etkinleştirebilirsiniz.

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

F# 6'da, her iki tür de bilindiğinde 32 bit tamsayılar 64 bit tamsayılara genişletilir. Örneğin, tipik bir API şeklini göz önünde bulundurun:

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

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

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

veya

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

F# 6'da, tür çıkarımı sırasında hem kaynak hem de hedef türü bilindiğinde için için , ile ve doubleiçin genişletme otomatik nativeintint64int32int32 olarak gerçekleşir.int32 Bu nedenle, önceki örnekler gibi durumlarda değişmez int32 değerler kullanılabilir:

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

Bu değişikliğe rağmen F# çoğu durumda sayısal türlerin açıkça genişletilmesi özelliğini kullanmaya devam eder. Örneğin, örtük genişletme, veya int16gibi diğer sayısal türler için geçerli değildir, örneğin int8 , ya da kaynak float32float64ya da hedef türü bilinmediğinde. Ayrıca, örtük dönüştürmeler için isteğe bağlı uyarılar bölümünde açıklandığı gibi, örtük sayısal genişletmenin kullanıldığı her noktada uyarı gösterilmesi için uyarıyı isteğe bağlı olarak etkinleştirebilirsiniz/warnon:3389.

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

F# 6'da yöntemleri çağırırken F# kodunda .NET "op_Implicit" dönüştürmeleri otomatik olarak uygulanır. Örneğin, F# 5'te XML için .NET API'leriyle çalışırken kullanılması XName.op_Implicit gerekiyordu:

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

F# 6'da dönüştürmeler, op_Implicit kaynak ifade ve hedef tür için türler kullanılabilir olduğunda bağımsız 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")

İsteğe bağlı olarak, /warnon:3395 örtük dönüştürmeler için isteğe bağlı uyarılar bölümünde açıklandığı gibi yöntem bağımsız değişkenlerinde kullanılan her nokta op_Implicit dönüştürme genişletmesinde bir uyarı göstermek üzere uyarıyı etkinleştirebilirsiniz.

Not

F# 6'nın ilk sürümünde bu uyarı numarası idi /warnon:3390. Çakışma nedeniyle uyarı numarası daha sonra olarak /warnon:3395güncelleştirildi.

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

Türe yönelik ve örtük dönüştürmeler, tür çıkarımıyla kötü etkileşimde bulunabilir ve anlaşılması daha zor olan kodlara yol açabilir. Bu nedenle, bu özelliğin F# kodunda kötüye kullanılmasına yardımcı olmak için bazı azaltmalar vardır. İlk olarak, hem kaynak hem de hedef türü kesin olarak bilinmeli ve belirsizlik veya ek tür çıkarımı olmamalıdır. İkinci olarak, örtük dönüştürmelerin kullanımını raporlamak için kabul uyarıları etkinleştirilebilir ve varsayılan olarak bir uyarı açıktır:

/warnon:3388 (ek örtük yukarı yayın)
/warnon:3389 (örtük sayısal genişletme)
/warnon:3391 (Varsayılan olarak açık olan yöntem dışı bağımsız değişkenlerde op_Implicit)
/warnon:3395 (yöntem bağımsız değişkenlerinde op_Implicit)

Ekibiniz örtük dönüştürmelerin tüm kullanımlarını yasaklamak istiyorsa , , /warnaserror:3389/warnaserror:3391ve /warnaserror:3395de belirtebilirsiniz/warnaserror:3388.

İkili sayılar için biçimlendirme

F# 6, ikili sayı biçimleri için kullanılabilir biçim tanımlayıcılarına deseni ekler %B . Aşağıdaki F# kodunu göz önünde bulundurun:

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

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

173
1111011

Bu özellik F# RFC FS-1100 uygular.

Kullanım bağlamalarını atar

F# 6 bir use bağlamada kullanılmasına izin verir_, örneğin:

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

Bu özellik F# RFC FS-1102 uygular.

InlineIfLambda

F# derleyicisi, kod için inlining 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 her zaman çağrı sitelerinde çizili olması gerektiğini belirtmesine olanak tanıyan yeni bir bildirim özelliği ekledik.

Örneğin, bir diziden geçiş yapmak için aşağıdaki iterateTwice işlevi göz önünde bulundurun:

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]

Arama sitesi şu şekildeyse:

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

Ardından, kod, inlining ve diğer iyileştirmelerden sonra şu hale gelir:

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

F# uygulamasının önceki sürümlerinden farklı olarak bu iyileştirme, söz konusu lambda ifadesinin boyutu ne olursa olsun uygulanır. Bu özellik, döngü kaydını kaldırma ve benzer dönüştürmeleri daha güvenilir bir şekilde uygulamak için de kullanılabilir.

Kodunuzda InlineIfLambda bağımsız değişkenlerin çağrı sitelerindeki lambda ifadelerine bağlı olmadığı yerleri belirtmek için bir kabul etme uyarısı (/warnon:3517varsayılan olarak kapalı) açılabilir. Normal durumlarda bu uyarı etkinleştirilmemelidir. Ancak, belirli yüksek performanslı programlama türlerinde, tüm kodların çizili ve düzleştirilmiş olduğundan emin olmak yararlı olabilir.

Bu özellik F# RFC FS-1098'i uygular.

Devam ettirilebilen kod

task {…} F# 6 desteği, RFC FS-1087 adlı birtemel üzerine kurulmuştur. Devam ettirilebilen kod, çok sayıda yüksek performanslı zaman uyumsuz ve verimli durum makinesi oluşturmak için kullanılabilen teknik bir özelliktir.

Ek koleksiyon işlevleri

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

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

Bu işlevlerin tümü ilgili koleksiyon türü veya dizisinde 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, ilgili belgelere (örneğin, List.insertAt) bakın.

Örnek olarak, Elmish stilinde yazılmış basit bir "Yapılacaklar Listesi" uygulaması için model, ileti ve güncelleştirme mantığını göz önünde bulundurun. Burada kullanıcı uygulamayla etkileşim kurarak ileti oluşturur ve update işlev bu iletileri işleyerek yeni bir model oluşturur:

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 dayanır.

Bu özellik F# RFC FS-1113'i uygular.

Eşleme anahtarlara ve değerlere sahiptir

FSharp.Core 6.0.0'da türü Map artık Anahtarlar ve Değerler özelliklerini destekler. 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ç bilgiler ekler:

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

içindeki diğer işlevlerde NativePtrolduğu gibi, bu işlevler de çizilidir ve kullanılmadığı sürece /nowarn:9 kullanımları uyarı gösterir. Bu işlevlerin kullanımı yönetilmeyen türlerde sınırlıdır.

Bu özellik F# RFC FS-1109'da belgelenmiştir.

Birim ek açıklamalarıyla ek sayısal türler

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

F# diğer adı	CLR Türü
`float32`/`single`	`System.Single`
`float`/`double`	`System.Double`
`decimal`	`System.Decimal`
`sbyte`/`int8`	`System.SByte`
`int16`	`System.Int16`
`int`/`int32`	`System.Int32`
`int64`	`System.Int64`
`byte`/`uint8`	`System.Byte`
`uint16`	`System.UInt16`
`uint`/`uint32`	`System.UInt32`
`uint64`	`System.UIn64`
`nativeint`	`System.IntPtr`
`unativeint`	`System.UIntPtr`

Örneğin, işaretsiz bir tamsayıya aşağıdaki gibi ek açıklama ekleyebilirsiniz:

[<Measure>]
type days

let better_age = 3u<days>

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

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

F# 6, F# 6 ve sonrasında , !, incrve decr kullanımını :=normalden çıkaran geçici yönergeler ekler. Bu işleçlerin ve işlevlerin kullanılması, kodunuzu özelliğin açık kullanımıyla Value değiştirmenizi gerektiren bilgilendirici iletiler oluşturur.

F# programlamada başvuru hücreleri yığınla ayrılmış değiştirilebilir yazmaçlar için kullanılabilir. Bazen yararlı olsalar da, modern F# kodlamasında nadiren kullanılırlar, çünkü let mutable bunun yerine kullanılabilirler. F# çekirdek kitaplığı iki işleç := ve ! iki işlev incr içerir ve decr özellikle başvuru çağrıları ile ilgilidir. Bu işleçlerin varlığı, başvuru hücrelerini F# programlamada olması gerekenden daha merkezi hale getirir ve tüm F# programcılarının bu işleçleri bilmesini zorunlu kılar. Ayrıca işleç C ! # ve diğer dillerdeki işlemle not kolayca karıştırılabilir ve kod çevirisi sırasında küçük hatalara neden olabilir.

Bu değişikliğin mantığı, F# programcısının bilmesi gereken işleç sayısını azaltmak ve böylece yeni başlayanlar için F# dilini basitleştirmektir.

Örneğin, aşağıdaki F# 5 kodunu göz önünde bulundurun:

let r = ref 0

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

İlk olarak, başvuru hücreleri modern F# kodlamasında nadiren gereklidir, bunun let mutable yerine normalde 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ı r.Value <- r.Value + 1olarak değiştirmenizi isteyen ve başvuru hücrelerinin uygun kullanımıyla ilgili daha fazla kılavuza sizi bağlayan bilgilendirıcı bir uyarı yayar.

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 kalır.

Bu özellik F# RFC FS-1111'i uygular.

F# araçları: Visual Studio'da betik oluşturma için varsayılan .NET 6

Visual Studio'da bir F# Betiği (.fsx) açar veya yürütürseniz, betik varsayılan olarak 64 bit yürütme ile .NET 6 kullanılarak analiz edilir ve yürütülür. Bu işlev, Visual Studio 2019'un sonraki sürümlerinde önizleme aşamasındaydı ve artık varsayılan olarak etkindir.

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

F# araçları: F# betiklerinizin SDK sürümünü sabitleme

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

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

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

Betiği şimdi kullanarak dotnet fsiyürütürseniz, bu dizinden SDK sürümüne saygı gösterilir. Bu, betiklerinizi derlemek, çözümlemek ve yürütmek için kullanılan SDK'yı "kilitlemenizi" sağlayan güçlü bir özelliktir.

Betiğinizi Visual Studio'da ve diğer IDE'lerde açar ve düzenlerseniz, betiğinizi analiz edip denetlerken araçlar bu ayara saygı gösterir. SDK bulunamazsa geliştirme makinenize yüklemeniz gerekir.

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

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

printfn "Hello, world"

Artık betik doğrudan ile script.fsxyürütülebilir. Bunu aşağıdaki gibi belirli, varsayılan olmayan bir dil sürümüyle birleştirebilirsiniz:

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

Not

Bu ayar düzenleme araçları tarafından yoksayılır ve betik en son dil sürümünü varsayarak analiz edilir.

Eski özellikleri kaldırma

F# 2.0'dan bu yana, kullanım dışı bırakılan bazı eski özellikler uzun süredir uyarılar vermiştir. F# 6'da bu özelliklerin kullanılması, açıkça kullanmadığınız /langversion:5.0sürece hata verir. Hata veren özellikler şunlardır:

Bir sonek türü adı kullanan birden çok genel parametre, örneğin (int, int) Dictionary. Bu, F# 6'da bir hataya dönüşür. Bunun yerine standart söz dizimi Dictionary<int,int> kullanılmalıdır.
#indent "off". Bu bir hataya dönüşür.
x.(expr). Bu bir hataya dönüşür.
module M = struct … end . Bu bir hataya dönüşür.
ve *.mligirişlerinin *.ml kullanımı. Bu bir hataya dönüşür.
veya (*IF-OCAML*)kullanımı(*IF-CAML*). Bu bir hataya dönüşür.
land, , lor, lxor, lsl, veya lsrasr infix işleçleri olarak kullanılır. Bunlar, OCaml'de infix anahtar sözcükleri olduklarından ve FSharp.Core'da tanımlanmadığından F# dilindeki infix anahtar sözcükleridir. Bu anahtar sözcüklerin kullanılması artık bir uyarı gösterir.

Bu, F# RFC FS-1114'i uygular.

Aracılığıyla paylaş

F# 6'daki yenilikler

Kullanmaya başlayın

{...} görevi

ile daha basit dizin oluşturma söz dizimi `expr[idx]`

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

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

"as" desenleri

Girinti söz dizimi düzeltmeleri

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

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

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

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

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

İkili sayılar için biçimlendirme

Kullanım bağlamalarını atar

InlineIfLambda

Devam ettirilebilen kod

Ek koleksiyon işlevleri

Eşleme anahtarlara ve değerlere sahiptir

NativePtr için ek iç bilgiler

Birim ek açıklamalarıyla ek sayısal türler

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

F# araçları: Visual Studio'da betik oluşturma için varsayılan .NET 6

F# araçları: F# betiklerinizin SDK sürümünü sabitleme

Eski özellikleri kaldırma

Geri Bildirim

Ek kaynaklar

Aracılığıyla paylaş

F# 6'daki yenilikler

Kullanmaya başlayın

{...} görevi

ile daha basit dizin oluşturma söz dizimi expr[idx]

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

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

"as" desenleri

Girinti söz dizimi düzeltmeleri

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

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

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

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

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

İkili sayılar için biçimlendirme

Kullanım bağlamalarını atar

InlineIfLambda

Devam ettirilebilen kod

Ek koleksiyon işlevleri

Eşleme anahtarlara ve değerlere sahiptir

NativePtr için ek iç bilgiler

Birim ek açıklamalarıyla ek sayısal türler

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

F# araçları: Visual Studio'da betik oluşturma için varsayılan .NET 6

F# araçları: F# betiklerinizin SDK sürümünü sabitleme

Eski özellikleri kaldırma

Geri Bildirim

Ek kaynaklar

ile daha basit dizin oluşturma söz dizimi `expr[idx]`