Когда использовать дискриминацию объединения и типа записи в F#

Подумайте об этом, как о записи «и», а о разделенном союзе — «или». Это строка и целое число:

type MyRecord = { myString: string
                  myInt: int }

в то время как это значение является либо строкой, либо целым числом, но не тем и другим одновременно:

type MyUnion = | Int of int
               | Str of string

Эта фиктивная игра может быть на титульном экране, в игре или отображать окончательный счет, но только в одном из этих вариантов.

type Game =
  | Title
  | Ingame of Player * Score * Turn
  | Endgame of Score

Используйте записи (называемые типами продуктов в теории функционального программирования) для сложных данных, которые описываются несколькими свойствами, такими как запись базы данных или какой-либо объект модели:

type User = { Username : string; IsActive : bool }

type Body = { 
    Position : Vector2<double<m>>
    Mass : double<kg>
    Velocity : Vector2<double<m/s>> 
}

Используйте размеченные объединения (называемые типами сумм) для данных, возможные значения которых можно перечислить. Например:

type NatNumber =
| One
| Two
| Three
...

type UserStatus =
| Inactive
| Active
| Disabled

type OperationResult<'T> =
| Success of 'T
| Failure of string

Обратите внимание, что возможные значения для размеченного значения объединения также являются взаимоисключающими — результатом операции может быть либо Success, либо Failure, но не оба одновременно.

Вы можете использовать тип записи для кодирования результата операции, например:

type OperationResult<'T> = { 
    HasSucceeded : bool
    ResultValue : 'T
    ErrorMessage : string
}

Но в случае сбоя операции это ResultValue не имеет смысла. Таким образом, сопоставление с образцом в размеченной версии объединения этого типа будет выглядеть так:

match result with
| Success resultValue -> ...
| Failure errorMessage -> ...

И если вы сопоставите шаблон с версией типа записи нашего типа операции, это будет иметь меньше смысла:

match result with
| { HasSucceeded = true; ResultValue = resultValue; ErrorMessage = _ } -> ...
| { HasSucceeded = false; ErrorMessage = errorMessage; ResultValue = _ } -> ...

Это выглядит многословно и неуклюже, и, вероятно, менее эффективно. Я думаю, когда у вас возникает такое чувство, это, вероятно, намек на то, что вы используете неправильный инструмент для задачи.

Если вы работаете с C#, вы можете понимать записи как запечатанные классы с добавленными значениями:

• Неизменяемый по умолчанию
• Структурное равенство по умолчанию
• Легко подобрать шаблон
• и т.п.

Размеченные союзы кодируют альтернативы, например.

type Expr =
    | Num of int
    | Var of int 
    | Add of Expr * Expr 
    | Sub of Expr * Expr

DU выше читается следующим образом: выражение является либо целым числом, или переменной, или сложением двух выражений, или вычитание между двумя выражениями. Эти случаи не могут происходить одновременно.

Вам нужны все поля для создания записи. Вы также можете использовать DU внутри записей и наоборот.

type Name =
    { FirstName : string;
      MiddleName : string option;
      LastName : string }

В приведенном выше примере показано, что отчество является необязательным.

В F# вы часто начинаете моделирование данных с кортежей или записей. Когда требуются расширенные функции, вы можете переместить их в классы.

С другой стороны, размеченные объединения используются для моделирования альтернатив и взаимоисключающих отношений между случаями.

Один (слегка ошибочный) способ понять DU — рассматривать его как причудливый «объединение» C#, в то время как запись больше похожа на обычный объект (с несколькими независимыми полями).

Другой способ взглянуть на DU — рассматривать DU как двухуровневую иерархию классов, где верхний тип DU — это абстрактный базовый класс, а случаи DU — это подклассы. Это представление на самом деле близко к фактической реализации .NET, хотя эта деталь скрыта компилятором.