Novinky v F# 5

Článek
03/12/2024

F# 5 přidává několik vylepšení jazyka F# a F# Interactive. Vydává se s .NET 5.

Nejnovější sadu .NET SDK si můžete stáhnout ze stránky pro stahování .NET.

Začínáme

F# 5 je k dispozici ve všech distribucích .NET Core a nástrojích sady Visual Studio. Další informace najdete v tématu Začínáme s jazykem F# a získejte další informace.

Odkazy na balíčky ve skriptech jazyka F#

Jazyk F# 5 přináší podporu odkazů na balíčky ve skriptech jazyka F# se #r "nuget:..." syntaxí. Představte si například následující odkaz na balíček:

#r "nuget: Newtonsoft.Json"

open Newtonsoft.Json

let o = {| X = 2; Y = "Hello" |}

printfn $"{JsonConvert.SerializeObject o}"

Za názvem balíčku můžete také zadat explicitní verzi, například takto:

#r "nuget: Newtonsoft.Json,11.0.1"

Odkazy na balíčky podporují balíčky s nativními závislostmi, například ML.NET.

Odkazy na balíčky také podporují balíčky se zvláštními požadavky na odkazování na závislé .dllpoložky. Například balíček FParsec, který se používá k tomu, aby uživatelé ručně zajistili, že jeho závislý FParsecCS.dll odkaz byl nejprve odkazován dříve, než FParsec.dll byl odkazován v F# Interactive. Tento postup už není potřeba a můžete na balíček odkazovat následujícím způsobem:

#r "nuget: FParsec"

open FParsec

let test p str =
    match run p str with
    | Success(result, _, _)   -> printfn $"Success: {result}"
    | Failure(errorMsg, _, _) -> printfn $"Failure: {errorMsg}"

test pfloat "1.234"

Tato funkce implementuje nástroje F# RFC FST-1027. Další informace o odkazech na balíčky najdete v kurzu F# Interactive .

Interpolace řetězců

Interpolované řetězce jazyka F# jsou poměrně podobné interpolovaným řetězcům jazyka C# nebo JavaScript, protože umožňují psát kód v "dírách" uvnitř řetězcového literálu. Tady je jednoduchý příklad:

let name = "Phillip"
let age = 29
printfn $"Name: {name}, Age: {age}"

printfn $"I think {3.0 + 0.14} is close to {System.Math.PI}!"

Interpolované řetězce jazyka F# však také umožňují typované interpolace stejně jako sprintf funkce vynutit, aby výraz uvnitř interpolovaného kontextu odpovídal určitému typu. Používá stejné specifikátory formátu.

let name = "Phillip"
let age = 29

printfn $"Name: %s{name}, Age: %d{age}"

// Error: type mismatch
printfn $"Name: %s{age}, Age: %d{name}"

V předchozím příkladu typované interpolace vyžaduje, %s aby interpolace byla typu string, zatímco %d interpolace vyžaduje, aby interpolace byla integer.

Kromě toho lze jakýkoli libovolný výraz jazyka F# (nebo výrazy) umístit na stranu kontextu interpolace. Je dokonce možné napsat složitější výraz, například takto:

let str =
    $"""The result of squaring each odd item in {[1..10]} is:
{
    let square x = x * x
    let isOdd x = x % 2 <> 0
    let oddSquares xs =
        xs
        |> List.filter isOdd
        |> List.map square
    oddSquares [1..10]
}
"""

I když to v praxi nedoporučujeme moc dělat.

Tato funkce implementuje F# RFC FS-1001.

Podpora názvu

F# 5 podporuje nameof operátor, který přeloží symbol, pro který se používá, a vytvoří jeho název ve zdroji F#. To je užitečné v různých scénářích, jako je protokolování, a chrání vaše protokolování před změnami ve zdrojovém kódu.

let months =
    [
        "January"; "February"; "March"; "April";
        "May"; "June"; "July"; "August"; "September";
        "October"; "November"; "December"
    ]

let lookupMonth month =
    if (month > 12 || month < 1) then
        invalidArg (nameof month) (sprintf "Value passed in was %d." month)

    months[month-1]

printfn $"{lookupMonth 12}"
printfn $"{lookupMonth 1}"
printfn $"{lookupMonth 13}"

Poslední řádek vyvolá výjimku a v chybové zprávě se zobrazí "měsíc".

Název téměř každého konstruktoru jazyka F#:

module M =
    let f x = nameof x

printfn $"{M.f 12}"
printfn $"{nameof M}"
printfn $"{nameof M.f}"

Tři konečné sčítání jsou změny v tom, jak fungují operátory: přidání nameof<'type-parameter> formuláře pro parametry obecného typu a možnost použít nameof jako vzor ve výrazu shody vzorů.

Když vezmete název operátoru, získáte jeho zdrojový řetězec. Pokud potřebujete zkompilovaný formulář, použijte zkompilovaný název operátoru:

nameof(+) // "+"
nameof op_Addition // "op_Addition"

Při přebírání názvu parametru typu se vyžaduje mírně odlišná syntaxe:

type C<'TType> =
    member _.TypeName = nameof<'TType>

To se podobá operátorům a typedefof<'T> operátorůmtypeof<'T>.

F# 5 také přidává podporu nameof vzoru, který lze použít ve match výrazech:

[<Struct; IsByRefLike>]
type RecordedEvent = { EventType: string; Data: ReadOnlySpan<byte> }

type MyEvent =
    | AData of int
    | BData of string

let deserialize (e: RecordedEvent) : MyEvent =
    match e.EventType with
    | nameof AData -> AData (JsonSerializer.Deserialize<int> e.Data)
    | nameof BData -> BData (JsonSerializer.Deserialize<string> e.Data)
    | t -> failwithf "Invalid EventType: %s" t

Předchozí kód místo řetězcového literálu ve výrazu shody používá "nameof".

Tato funkce implementuje F# RFC FS-1003.

Deklarace typu Otevření

F# 5 také přidává podporu deklarací otevřeného typu. Deklarace otevřeného typu je podobná otevření statické třídy v jazyce C#, s výjimkou jiné syntaxe a jiného mírně odlišného chování pro sémantiku jazyka F#.

U deklarací otevřeného typu můžete open libovolný typ zpřístupnit statický obsah uvnitř. Kromě toho můžete open sjednocovat a záznamy definované jazykem F#, abyste zpřístupnili jejich obsah. To může být užitečné například v případě, že máte sjednocení definované v modulu a chcete získat přístup k jeho případům, ale nechcete otevřít celý modul.

open type System.Math

let x = Min(1.0, 2.0)

module M =
    type DU = A | B | C

    let someOtherFunction x = x + 1

// Open only the type inside the module
open type M.DU

printfn $"{A}"

Na rozdíl od jazyka C# platí, že pokud jste open type na dvou typech, které zpřístupňují člen se stejným názvem, člen z posledního typu openstínuje druhý název. To je konzistentní s sémantikou jazyka F# kolem stínování, které už existují.

Tato funkce implementuje F# RFC FS-1068.

Konzistentní chování řezů pro předdefinované datové typy

Chování při vytváření řezů předdefinovaných FSharp.Core datových typů (matice, seznam, řetězec, 2D pole, 3D pole, 4D matice) používané k tomu, aby nebyly konzistentní před F# 5. Některé chování hraničních případů vyvolalo výjimku a některé ne. V jazyce F# 5 teď všechny předdefinované typy vrací prázdné řezy pro řezy, které nelze vygenerovat:

let l = [ 1..10 ]
let a = [| 1..10 |]
let s = "hello!"

// Before: would return empty list
// F# 5: same
let emptyList = l[-2..(-1)]

// Before: would throw exception
// F# 5: returns empty array
let emptyArray = a[-2..(-1)]

// Before: would throw exception
// F# 5: returns empty string
let emptyString = s[-2..(-1)]

Tato funkce implementuje F# RFC FS-1077.

Řezy s pevným indexem pro 3D a 4D pole v FSharp.Core

F# 5 přináší podporu vytváření řezů s pevným indexem v integrovaných 3D a 4D typech polí.

Pro ilustraci zvažte následující 3D pole:

z = 0

x\y	0	1
0	0	1
1	2	3

z = 1

x\y	0	1
0	4	5
1	6	7

Co když chcete extrahovat řez [| 4; 5 |] z pole? To je teď velmi jednoduché!

// First, create a 3D array to slice

let dim = 2
let m = Array3D.zeroCreate<int> dim dim dim

let mutable count = 0

for z in 0..dim-1 do
    for y in 0..dim-1 do
        for x in 0..dim-1 do
            m[x,y,z] <- count
            count <- count + 1

// Now let's get the [4;5] slice!
m[*, 0, 1]

Tato funkce implementuje F# RFC FS-1077b.

Vylepšení uvozovek jazyka F#

Uvozovky kódu jazyka F# teď mají možnost zachovat informace o omezení typu. Představte si následující příklad:

open FSharp.Linq.RuntimeHelpers

let eval q = LeafExpressionConverter.EvaluateQuotation q

let inline negate x = -x
// val inline negate: x: ^a ->  ^a when  ^a : (static member ( ~- ) :  ^a ->  ^a)

<@ negate 1.0 @>  |> eval

Omezení vygenerované inline funkcí je zachováno v uvozovkách kódu. Formulář negate citované funkce se teď dá vyhodnotit.

Tato funkce implementuje F# RFC FS-1071.

Výrazy aplikativních výpočtů

Výrazy výpočtů (CE) se dnes používají k modelování "kontextových výpočtů" nebo v funkčnější programovací terminologii, monadicích výpočtů.

F# 5 zavádí aplikační CE, které nabízejí jiný výpočetní model. Aplikace CE umožňují efektivnější výpočty za předpokladu, že jsou všechny výpočty nezávislé a jejich výsledky se na konci hromadí. Pokud jsou výpočty nezávislé na sobě, jsou také triviálně paralelizovatelné, což autorům CE umožňuje psát efektivnější knihovny. Tato výhoda se ale omezuje: výpočty, které závisí na dříve vypočítaných hodnotách, nejsou povolené.

Následující příklad ukazuje základní aplikativní CE pro Result typ.

// First, define a 'zip' function
module Result =
    let zip x1 x2 =
        match x1,x2 with
        | Ok x1res, Ok x2res -> Ok (x1res, x2res)
        | Error e, _ -> Error e
        | _, Error e -> Error e

// Next, define a builder with 'MergeSources' and 'BindReturn'
type ResultBuilder() =
    member _.MergeSources(t1: Result<'T,'U>, t2: Result<'T1,'U>) = Result.zip t1 t2
    member _.BindReturn(x: Result<'T,'U>, f) = Result.map f x

let result = ResultBuilder()

let run r1 r2 r3 =
    // And here is our applicative!
    let res1: Result<int, string> =
        result {
            let! a = r1
            and! b = r2
            and! c = r3
            return a + b - c
        }

    match res1 with
    | Ok x -> printfn $"{nameof res1} is: %d{x}"
    | Error e -> printfn $"{nameof res1} is: {e}"

let printApplicatives () =
    let r1 = Ok 2
    let r2 = Ok 3 // Error "fail!"
    let r3 = Ok 4

    run r1 r2 r3
    run r1 (Error "failure!") r3

Pokud jste autor knihovny, který dnes zveřejňuje CE v knihovně, je potřeba vzít v úvahu některé další aspekty.

Tato funkce implementuje F# RFC FS-1063.

Rozhraní je možné implementovat v různých obecných instancích.

Teď můžete implementovat stejné rozhraní v různých obecných instancích:

type IA<'T> =
    abstract member Get : unit -> 'T

type MyClass() =
    interface IA<int> with
        member x.Get() = 1
    interface IA<string> with
        member x.Get() = "hello"

let mc = MyClass()
let iaInt = mc :> IA<int>
let iaString = mc :> IA<string>

iaInt.Get() // 1
iaString.Get() // "hello"

Tato funkce implementuje F# RFC FS-1031.

Výchozí spotřeba členů rozhraní

F# 5 umožňuje využívat rozhraní s výchozími implementacemi.

Zvažte rozhraní definované v jazyce C# takto:

using System;

namespace CSharp
{
    public interface MyDim
    {
        public int Z => 0;
    }
}

V jazyce F# ho můžete využívat prostřednictvím libovolného standardního způsobu implementace rozhraní:

open CSharp

// You can implement the interface via a class
type MyType() =
    member _.M() = ()

    interface MyDim

let md = MyType() :> MyDim
printfn $"DIM from C#: %d{md.Z}"

// You can also implement it via an object expression
let md' = { new MyDim }
printfn $"DIM from C# but via Object Expression: %d{md'.Z}"

Díky tomu můžete bezpečně využívat kód jazyka C# a komponenty .NET napsané v moderním jazyce C#, když očekávají, že uživatelé budou moct využívat výchozí implementaci.

Tato funkce implementuje F# RFC FS-1074.

Zjednodušená spolupráce s typy hodnot s možnou hodnotou null

F# už dlouho podporuje typy s možnou hodnotou Nullable (hodnoty), ale interakce s nimi byla tradičně poněkud bolestí, protože byste museli vytvořit nebo Nullable<SomeType> obálku Nullable pokaždé, když chcete předat hodnotu. Kompilátor teď implicitně převede typ hodnoty na Nullable<ThatValueType> typ, pokud se cílový typ shoduje. Nyní je možný následující kód:

#r "nuget: Microsoft.Data.Analysis"

open Microsoft.Data.Analysis

let dateTimes = PrimitiveDataFrameColumn<DateTime>("DateTimes")

// The following line used to fail to compile
dateTimes.Append(DateTime.Parse("2019/01/01"))

// The previous line is now equivalent to this line
dateTimes.Append(Nullable<DateTime>(DateTime.Parse("2019/01/01")))

Tato funkce implementuje F# RFC FS-1075.

Preview: reverzní indexy

F# 5 také zavádí verzi Preview pro povolení reverzních indexů. Syntaxe je ^idx. Tady je postup, jak můžete hodnotu prvku 1 z konce seznamu:

let xs = [1..10]

// Get element 1 from the end:
xs[^1]

// From the end slices

let lastTwoOldStyle = xs[(xs.Length-2)..]

let lastTwoNewStyle = xs[^1..]

lastTwoOldStyle = lastTwoNewStyle // true

Můžete také definovat reverzní indexy pro vlastní typy. K tomu budete muset implementovat následující metodu:

GetReverseIndex: dimension: int -> offset: int

Tady je příklad pro Span<'T> typ:

open System

type Span<'T> with
    member sp.GetSlice(startIdx, endIdx) =
        let s = defaultArg startIdx 0
        let e = defaultArg endIdx sp.Length
        sp.Slice(s, e - s)

    member sp.GetReverseIndex(_, offset: int) =
        sp.Length - offset

let printSpan (sp: Span<int>) =
    let arr = sp.ToArray()
    printfn $"{arr}"

let run () =
    let sp = [| 1; 2; 3; 4; 5 |].AsSpan()

    // Pre-# 5.0 slicing on a Span<'T>
    printSpan sp[0..] // [|1; 2; 3; 4; 5|]
    printSpan sp[..3] // [|1; 2; 3|]
    printSpan sp[1..3] // |2; 3|]

    // Same slices, but only using from-the-end index
    printSpan sp[..^0] // [|1; 2; 3; 4; 5|]
    printSpan sp[..^2] // [|1; 2; 3|]
    printSpan sp[^4..^2] // [|2; 3|]

run() // Prints the same thing twice

Tato funkce implementuje F# RFC FS-1076.

Preview: Přetížení vlastních klíčových slov ve výpočetních výrazech

Výpočetní výrazy jsou výkonnou funkcí pro autory knihoven a architektur. Umožňují výrazně zlepšit výraznost komponent tím, že vám umožní definovat dobře známé členy a vytvořit DSL pro doménu, ve které pracujete.

F# 5 přidává podporu náhledu pro přetížení vlastních operací ve výpočetních výrazech. Umožňuje zápis a využívání následujícího kódu:

open System

type InputKind =
    | Text of placeholder:string option
    | Password of placeholder: string option

type InputOptions =
  { Label: string option
    Kind : InputKind
    Validators : (string -> bool) array }

type InputBuilder() =
    member t.Yield(_) =
      { Label = None
        Kind = Text None
        Validators = [||] }

    [<CustomOperation("text")>]
    member this.Text(io, ?placeholder) =
        { io with Kind = Text placeholder }

    [<CustomOperation("password")>]
    member this.Password(io, ?placeholder) =
        { io with Kind = Password placeholder }

    [<CustomOperation("label")>]
    member this.Label(io, label) =
        { io with Label = Some label }

    [<CustomOperation("with_validators")>]
    member this.Validators(io, [<ParamArray>] validators) =
        { io with Validators = validators }

let input = InputBuilder()

let name =
    input {
    label "Name"
    text
    with_validators
        (String.IsNullOrWhiteSpace >> not)
    }

let email =
    input {
    label "Email"
    text "Your email"
    with_validators
        (String.IsNullOrWhiteSpace >> not)
        (fun s -> s.Contains "@")
    }

let password =
    input {
    label "Password"
    password "Must contains at least 6 characters, one number and one uppercase"
    with_validators
        (String.exists Char.IsUpper)
        (String.exists Char.IsDigit)
        (fun s -> s.Length >= 6)
    }

Před touto změnou můžete typ napsat InputBuilder tak, jak je, ale nemůžete ho použít tak, jak se v příkladu používá. Vzhledem k tomu, že jsou povolené přetížení, volitelné parametry a typy System.ParamArray , všechno funguje tak, jak byste očekávali.

Tato funkce implementuje F# RFC FS-1056.

Sdílet prostřednictvím