F#
Дискриминационные союзы
Поиск…
Именование элементов кортежей в рамках дискриминационных союзов
При определении дискриминационных союзов вы можете назвать элементы типов кортежей и использовать эти имена во время сопоставления шаблонов.
type Shape =
| Circle of diameter:int
| Rectangle of width:int * height:int
let shapeIsTenWide = function
| Circle(diameter=10)
| Rectangle(width=10) -> true
| _ -> false
Кроме того, именование элементов дискриминационных объединений улучшает читаемость кода и совместимость с именами, указанными в C #, будут использоваться для имен свойств и параметров конструкторов. По умолчанию сгенерированные имена в коде взаимодействия являются «Item», «Item1», «Item2» ...
Использование основного дискриминационного союза
Дискриминационные союзы в F # предлагают способ определения типов, которые могут содержать любое количество разных типов данных. Их функциональность подобна объединениям C ++ или вариантам VB, но с дополнительным преимуществом безопасного типа.
// 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
Информация о типе не требуется включать в случаи дискриминационного союза. Опуская информацию о типе, вы можете создать объединение, которое просто представляет собой набор вариантов, аналогично перечислению.
// 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
Преобразование в строки и из строк с отражением
Иногда необходимо преобразовать дискриминированный союз в строку и из нее:
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
Единый случай дискриминации
Единственный случай, когда дискриминационный союз подобен любому другому дискриминационному союзу, за исключением того, что он имеет только один случай.
// 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
Он полезен для обеспечения безопасности типов и обычно используется в F #, в отличие от C # и Java, где создание новых типов требует дополнительных накладных расходов.
Следующие два альтернативных типа определения приводят к объявлению одного и того же объявленного единственного случая:
type OrderId = | OrderId of int
type OrderId =
| OrderId of int
Использование дискретизированных отдельных случаев в качестве записей
Иногда бывает полезно создавать типы объединения только с одним случаем для реализации типа записей:
type Point = Point of float * float
let point1 = Point(0.0, 3.0)
let point2 = Point(-2.5, -4.0)
Они становятся очень полезными, потому что их можно разложить с помощью сопоставления с образцом так же, как аргументы кортежа:
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
С атрибутом RequireQualifiedAccess
, случаи объединения должны упоминаться как MyUnion.MyCase
а не только MyCase
. Это предотвращает конфликты имен во вмещающем пространстве имен или модуле:
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
Если, например, System
была открыта, Single
относится к System.Single
. Нет столкновения с профсоюзным случаем. Requirements.Single
.
Рекурсивные дискриминационные союзы
Рекурсивный тип
Дискриминационные союзы могут быть рекурсивными, то есть они могут ссылаться на себя в своем определении. Главным примером здесь является дерево:
type Tree =
| Branch of int * Tree list
| Leaf of int
В качестве примера давайте определим следующее дерево:
1
2 5
3 4
Мы можем определить это дерево, используя наш рекурсивный дискриминированный союз следующим образом:
let leaf1 = Leaf 3
let leaf2 = Leaf 4
let leaf3 = Leaf 5
let branch1 = Branch (2, [leaf1; leaf2])
let tip = Branch (1, [branch1; leaf3])
Итерация по дереву - это просто вопрос соответствия шаблонов:
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]
Взаимно зависимые рекурсивные типы
Одним из способов достижения рекурсии является наличие вложенных взаимозависимых типов.
// 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
Определение типа записи непосредственно внутри дискриминационного объединения устарело:
// BAD
type Expression =
| LiteralExpr of obj
| ArithmeticExpr of {left: Expression; op:string; right: Expression}
// illegal in recent F# versions
Вы можете использовать and
ключевое слово для цепочки взаимозависимых определений:
// GOOD
type Arithmetic = {left: Expression; op:string; right: Expression}
and Expression =
| LiteralExpr of obj
| ArithmeticExpr of Arithmetic