[Перевод] 5. Проектирование с помощью типов: Делаем состояние явным

module EmailAddress =
    type T = EmailAddress of string
    let create (s:string) =
        if System.Text.RegularExpressions.Regex.IsMatch(s,@"^\S+@\S+\.\S+$")
            then Some (EmailAddress s)
            else None

module EmailAddress =
    type T =
        | ValidEmailAddress of string
        | InvalidEmailAddress of string
    let create (s:string) =
        if System.Text.RegularExpressions.Regex.IsMatch(s,@"^\S+@\S+\.\S+$")
            then ValidEmailAddress s    // изменили тип результата
            else InvalidEmailAddress s  // изменили тип результата
    // проверяем
    let valid = create "abc@example.com"
    let invalid = create "example.com"

let sendMessageTo t =
    match t with
    | ValidEmailAddress email ->
         // отправить электронное письмо
    | InvalidEmailAddress _ ->
         // игнорировать

• Электронный адрес может иметь состояния «Непроверенный» и «Проверенный». Переход из «Непроверенного» состояния в «Проверенное» происходит, когда пользователь подтверждает электронный адрес, перейдя по ссылке.
  
  Диаграмма переходов: Проверка электронного адрес
  
• Корзина может иметь состояния «Пустая», «Активная» и «Оплаченная». Переход из «Пустого» состояния в «Активное», происходит при добавлении первого товара в корзину, а в «Оплаченное» — при оплате.
  
  Диаграмма переходов: Корзина
  
• В игре шахматы, могут быть состояния «Ход Белых», «Ход Чёрных» и «Игра Завершена». Переход от «Хода Белых» к «Ходу Чёрных» происходит после хода белых, а к состоянию «Игра Завершена» — после мата.
  
  Диаграмма переходов: Шахматы

type ActiveCartData = { UnpaidItems: string list }
type PaidCartData = { PaidItems: string list; Payment: float }
type ShoppingCart =
    | EmptyCart  // нет данных
    | ActiveCart of ActiveCartData
    | PaidCart of PaidCartData

let addItem cart item =
    match cart with
    | EmptyCart ->
        // создать новую активную корзину с одним товаром
        ActiveCart {UnpaidItems=[item]}
    | ActiveCart {UnpaidItems=existingItems} ->
        // создать новую активную карту с ещё одним товаром
        ActiveCart {UnpaidItems = item :: existingItems}
    | PaidCart _ ->
        // игнорировать
        cart
let makePayment cart payment =
    match cart with
    | EmptyCart ->
        // игнорировать
        cart
    | ActiveCart {UnpaidItems=existingItems} ->
        // создать оплаченную карту с платежом
        PaidCart {PaidItems = existingItems; Payment=payment}
    | PaidCart _ ->
        // игнорировать
        cart

let makePayment2 activeCart payment =
    let {UnpaidItems=existingItems} = activeCart
    {PaidItems = existingItems; Payment=payment}

// оригинальная функция
val makePayment : ShoppingCart -> float -> ShoppingCart
// новая более конкретная функция
val makePayment2 :  ActiveCartData -> float -> PaidCartData

let paymentReport paidCarts =
    let printOneLine {Payment=payment} =
        printfn "Paid %f for items" payment
    paidCarts |> List.iter printOneLine

type EmailContactInfo =
    {
    EmailAddress: EmailAddress.T;
    IsEmailVerified: bool;
    }

• Бизнес-правило: «Подтверждающие письма должны отсылаться только заказчикам с неподтверждёнными электронными адресами»
  
• Бизнес-правило: «Письма с ссылкой на сброс пароля должны отсылаться только заказчикам с подтверждёнными электронными адресами»

• Для состояния «Не проверен», единственные данные, которые надо сохранить — это электронный адрес.
  
• Для состояния «Проверен» мы можем хранить дополнительные данные: дату проверки, количество запросов на сброс пароля и т. д. Эти данные не подходят (и не должны быть доступны) для состояния «Непроверенный».

module EmailContactInfo =
    open System
    // заглушка
    type EmailAddress = string
    // UnverifiedData = просто электронный адрес
    type UnverifiedData = EmailAddress
    // VerifiedData = электронный адрес плюс дата проверки
    type VerifiedData = EmailAddress * DateTime
    // множество состояний
    type T =
        | UnverifiedState of UnverifiedData
        | VerifiedState of VerifiedData

• Конструирование всегда возвращает непроверенный электронный адрес. Это просто.
  
• Есть всего одно событие «проверен», которое переводит автомат в новое состояние.

module EmailContactInfo =
    // типы как выше
    let create email =
        // непроверенное при создании
        UnverifiedState email
    // обработать событие "проверен"
    let verified emailContactInfo dateVerified =
        match emailContactInfo with
        | UnverifiedState email ->
            // создать новый объект в состоянии Проверенный
            VerifiedState (email, dateVerified)
        | VerifiedState _ ->
            // игнорировать
            emailContactInfo

module EmailContactInfo =
    // типы и функции как выше
    let sendVerificationEmail emailContactInfo =
        match emailContactInfo with
        | UnverifiedState email ->
            // отправить электронное письмо
            printfn "отправка электронного письма"
        | VerifiedState _ ->
            // ничего не делать
            ()
    let sendPasswordReset emailContactInfo =
        match emailContactInfo with
        | UnverifiedState email ->
            // игнорировать
            ()
        | VerifiedState _ ->
            // запросить сброс пароля
            printfn "запрос сброса пароля"

• Правило: «Нельзя отправить посылку, если она уже отправлена»
  
• Правило: «Нельзя расписаться за посылку, которая уже доставлена»

open System
type PackageStatus =
    | Undelivered
    | OutForDelivery
    | Delivered
type Package =
    {
    PackageId: int;
    PackageStatus: PackageStatus;
    DeliveryDate: DateTime;
    DeliverySignature: string;
    }

let putOnTruck package =
    {package with PackageStatus=OutForDelivery}
let signedFor package signature =
    let {PackageStatus=packageStatus} = package
    if (packageStatus = Undelivered)
    then
        failwith "посылка не отправлена (package not out for delivery)"
    else if (packageStatus = OutForDelivery)
    then
        {package with
            PackageStatus=OutForDelivery;
            DeliveryDate = DateTime.UtcNow;
            DeliverySignature=signature;
            }
    else
        failwith "посылка уже доставлена (package already delivered)"

• Как быть, если при обработке события «отправить», статус посылки — уже OutForDelivery (в доставке) или Delivered (доставлена)? В коде ничего про это не сказано.
  
• При обработке события «расписаться» мы обрабатываем все состояния, но последняя ветка else подразумевает, что у нас только три состояния, и не проверяет состояние явным образом. Этот код станет неправильным, если нам потребуется новый статус.
  
• Наконец, из-за того, что DeliveryDate и DeliverySignature описаны в основной структуре, им случайно можно присвоить значения, даже если посылка не перешла в статус Delivered.

open System
type UndeliveredData =
    {
    PackageId: int;
    }
type OutForDeliveryData =
    {
    PackageId: int;
    }
type DeliveredData =
    {
    PackageId: int;
    DeliveryDate: DateTime;
    DeliverySignature: string;
    }
type Package =
    | Undelivered of UndeliveredData
    | OutForDelivery of OutForDeliveryData
    | Delivered of DeliveredData

let putOnTruck package =
    match package with
    | Undelivered {PackageId=id} ->
        OutForDelivery {PackageId=id}
    | OutForDelivery _ ->
        failwith "посылка уже отправлена (package already out)"
    | Delivered _ ->
        failwith "послыка уже доставлена (package already delivered)"
let signedFor package signature =
    match package with
    | Undelivered _ ->
        failwith "послыка не отправлена (package not out)"
    | OutForDelivery {PackageId=id} ->
        Delivered {
            PackageId=id;
            DeliveryDate = DateTime.UtcNow;
            DeliverySignature=signature;
            }
    | Delivered _ ->
        failwith "послыка уже доставлена (package already delivered)"

open System
type Order =
    {
    OrderId: int;
    PlacedDate: DateTime;
    PaidDate: DateTime option;
    PaidAmount: float option;
    ShippedDate: DateTime option;
    ShippingMethod: string option;
    ReturnedDate: DateTime option;
    ReturnedReason: string option;
    }

let makePayment order payment =
    if (order.PaidDate.IsSome)
    then failwith "заказ уже оплачен (order is already paid)"
    //вернуть обновлённый заказ с информацией об оплате
    {order with
        PaidDate=Some DateTime.UtcNow
        PaidAmount=Some payment
        }
let shipOrder order shippingMethod =
    if (order.ShippedDate.IsSome)
    then failwith "заказ уже отправлен (order is already shipped)"
    //вернуть обновлённый заказ с информацией об отправке
    {order with
        ShippedDate=Some DateTime.UtcNow
        ShippingMethod=Some shippingMethod
        }

open System
type InitialOrderData =
    {
    OrderId: int;
    PlacedDate: DateTime;
    }
type PaidOrderData =
    {
    Date: DateTime;
    Amount: float;
    }
type ShippedOrderData =
    {
    Date: DateTime;
    Method: string;
    }
type ReturnedOrderData =
    {
    Date: DateTime;
    Reason: string;
    }
type Order =
    | Unpaid of InitialOrderData
    | Paid of InitialOrderData * PaidOrderData
    | Shipped of InitialOrderData * PaidOrderData * ShippedOrderData
    | Returned of InitialOrderData * PaidOrderData * ShippedOrderData * ReturnedOrderData

let makePayment order payment =
    match order with
    | Unpaid i ->
        let p = {Date=DateTime.UtcNow; Amount=payment}
        // возвращаем оплаченный заказ
        Paid (i,p)
    | _ ->
        printfn "заказ уже оплачен (order is already paid)"
        order
let shipOrder order shippingMethod =
    match order with
    | Paid (i,p) ->
        let s = {Date=DateTime.UtcNow; Method=shippingMethod}
        // возвращаем отправленный заказ
        Shipped (i,p,s)
    | Unpaid _ ->
        printfn "заказ ещё не оплачен (order is not paid for)"
        order
    | _ ->
        printfn "заказ уже отправлен (order is already shipped)"
        order

• У вас есть взаимоисключающие состояния с переходами между ними.
  
• Переходы вызываются внешними событиями.
  
• Перечень состояний исчерпывающий. Других возможностей нет и вы должны обрабатывать все варианты.
  
• У каждого состояния могут быть связанные данные, недоступные, когда система находится в другом состоянии.
  
• Есть неизменные бизнес-правила, которые применяются к состояниям.