F#
Gediscrimineerde vakbonden

Elementen van tupels benoemen binnen gediscrimineerde vakbonden

Bij het definiëren van gediscrimineerde vakbonden kunt u elementen van tupeltypen een naam geven en deze namen gebruiken tijdens patroonovereenkomst.

type Shape = 
    | Circle of diameter:int
    | Rectangle of width:int * height:int

let shapeIsTenWide = function
    | Circle(diameter=10) 
    | Rectangle(width=10) -> true
    | _ -> false

Het benoemen van de elementen van gediscrimineerde vakbonden verbetert bovendien de leesbaarheid van de code en de interoperabiliteit met C # - op voorwaarde dat namen worden gebruikt voor de namen van eigenschappen en parameters van constructeurs. Standaard gegenereerde namen in interop-code zijn "Artikel", "Artikel 1", "Artikel 2" ...

Basis discriminerend gebruik in de Unie

Gediscrimineerde vakbonden in F # bieden een manier om typen te definiëren die elk aantal verschillende gegevenstypen kunnen bevatten. Hun functionaliteit is vergelijkbaar met C ++ unies of VB-varianten, maar met het extra voordeel dat ze type-veilig zijn.

// define a discriminated union that can hold either a float or a string
type numOrString = 
    | F of float
    | S of string

let str = S "hi" // use the S constructor to create a string
let fl = F 3.5 // use the F constructor to create a float

// you can use pattern matching to deconstruct each type
let whatType x = 
    match x with
        | F f -> printfn "%f is a float" f
        | S s -> printfn "%s is a string" s

whatType str // hi is a string
whatType fl // 3.500000 is a float

Enum-stijl vakbonden

Type-informatie hoeft niet te worden opgenomen in het geval van een gediscrimineerde unie. Door type-informatie weg te laten, kunt u een unie maken die eenvoudig een reeks keuzes vertegenwoordigt, vergelijkbaar met een opsomming.

// This union can represent any one day of the week but none of 
// them are tied to a specific underlying F# type
type DayOfWeek = Monday | Tuesday | Wednesday | Thursday | Friday | Saturday | Sunday

Converteren van en naar tekenreeksen met Reflectie

Soms is het nodig om een Discriminated Union van en naar een string te converteren:

module UnionConversion 
    open Microsoft.FSharp.Reflection
    
    let toString (x: 'a) = 
        match FSharpValue.GetUnionFields(x, typeof<'a>) with
        | case, _ -> case.Name

    let fromString<'a> (s : string) =
        match FSharpType.GetUnionCases typeof<'a> |> Array.filter (fun case -> case.Name = s) with 
        | [|case|] -> Some(FSharpValue.MakeUnion(case, [||])) :?> 'a)
        | _ -> None

Gediscrimineerde unie

Een enkele geval-discriminerende unie is net als elke andere gediscrimineerde unie, behalve dat het slechts één geval heeft.

// Define single-case discriminated union type.
type OrderId = OrderId of int
// Construct OrderId type.
let order = OrderId 123
// Deconstruct using pattern matching. 
// Parentheses used so compiler doesn't think it is a function definition.   
let (OrderId id) = order

Het is handig voor het afdwingen van typeveiligheid en wordt vaak gebruikt in F # in tegenstelling tot C # en Java waarbij het maken van nieuwe typen meer overhead met zich meebrengt.

De volgende twee alternatieve typedefinities leiden ertoe dat dezelfde afzonderlijke geval van discriminatie wordt verklaard:

type OrderId = | OrderId of int

type OrderId =
      | OrderId of int

Gediscrimineerde vakbonden in één geval gebruiken als records

Soms is het handig om unietypen te maken met slechts één case om recordachtige typen te implementeren:

type Point = Point of float * float

let point1 = Point(0.0, 3.0)

let point2 = Point(-2.5, -4.0)

Deze worden erg handig omdat ze via patroonafstemming op dezelfde manier kunnen worden ontleed als argumenten van tuple:

let (Point(x1, y1)) = point1
// val x1 : float = 0.0
// val y1 : float = 3.0

let distance (Point(x1,y1)) (Point(x2,y2)) =
    pown (x2-x1) 2 + pown (y2-y1) 2 |> sqrt
// val distance : Point -> Point -> float

distance point1 point2
// val it : float = 7.433034374

RequireQualifiedAccess

Met het kenmerk RequireQualifiedAccess moeten uniezaken worden aangeduid als MyUnion.MyCase plaats van alleen MyCase . Dit voorkomt naambotsingen in de omringende naamruimte of module:

type [<RequireQualifiedAccess>] Requirements =
    None | Single | All

// Uses the DU with qualified access
let noRequirements = Requirements.None

// Here, None still refers to the standard F# option case
let getNothing () = None

// Compiler error unless All has been defined elsewhere
let invalid = All

Als bijvoorbeeld System is geopend, verwijst Single naar System.Single . Er is geen botsing met de vakbond Requirements.Single .

Recursieve gediscrimineerde vakbonden

Recursief type

Gediscrimineerde vakbonden kunnen recursief zijn, dat wil zeggen dat ze naar zichzelf kunnen verwijzen in hun definitie. Het belangrijkste voorbeeld hier is een boom:

type Tree =
    | Branch of int * Tree list
    | Leaf of int

Laten we als voorbeeld de volgende boom definiëren:

    1
  2   5
3   4

We kunnen deze boom als volgt definiëren met behulp van onze recursieve gediscrimineerde unie:

let leaf1 = Leaf 3
let leaf2 = Leaf 4
let leaf3 = Leaf 5

let branch1 = Branch (2, [leaf1; leaf2])
let tip = Branch (1, [branch1; leaf3])

Over de boom heen gaan is dan alleen een kwestie van patroonovereenkomst:

let rec toList tree =
    match tree with
    | Leaf x -> [x]
    | Branch (x, xs) -> x :: (List.collect toList xs)

let treeAsList = toList tip // [1; 2; 3; 4; 5]

Wederzijds afhankelijke recursieve typen

Een manier om recursie te bereiken is om geneste onderling afhankelijke types te hebben.

// BAD
type Arithmetic = {left: Expression; op:string; right: Expression}
// illegal because until this point, Expression is undefined
type Expression = 
| LiteralExpr of obj
| ArithmeticExpr of Arithmetic

Het definiëren van een recordtype direct in een gediscrimineerde unie is verouderd:

// BAD
type Expression = 
| LiteralExpr of obj
| ArithmeticExpr of {left: Expression; op:string; right: Expression}
// illegal in recent F# versions

U kunt het gebruiken and zoekwoorden aan de ketting onderling afhankelijk definities:

// GOOD
type Arithmetic = {left: Expression; op:string; right: Expression}
and Expression = 
| LiteralExpr of obj
| ArithmeticExpr of Arithmetic