関数型ドメインモデリング

Bounded Context: Order-Taking

Workflow: "Place Order"
    triggered by:
        "Order form received" event
    primary input:
        Product catalog
    output events:
        "Order Placed" event
    side-effects:
        An acknowledgment is send to the customer,
        alog with the placed order

bounded context: Order-Taking

data Order =
    CustomerInfo
    AND ShippingAddress
    AND BillingAddress
    AND List of OrderLines
    AND AbountToBill

data OrderLine =
    Product
    AND Quantity
    AND Price

data CustomerInfo = ?
data BillingAddress = ?

context: Order-Taking

# 装置コード
data WidgetCode = string starting with "W" then 4 digits
# 機器コード
data GizmoCode = ~~~~
# 製品コード
data ProductCode = WidgetCode or GizmoCode

# 数量要件
data OrderQuantity = UnitQuantitiy OR KilogramQuantity
data UnitQuantity = interger between 1 and ?
data KilogramQuantity = decimal between ? and ?

data UnvalidatedOrder =
    UnvalidatedInfo
    AND UnvalidatedShippingAddress

data UnvalidtedOrderLine =
    UnvalidatedProduct

data ValidatedOrder =
    validatedInfo
    AND validatedShippingAddress

data ValidtedOrderLine =
    ValidatedProduct

data PricedOrder =
    ValidatedCustomerInfo
    AND ValidatedShippingAddress
    AND ValidatedBillingAddress
    AND List of PricedOrderLine
    AND AmountToBill

data PricedOrderLine
    ValidatedOrderLine
    AND LinePrice

data PlacedOrderAcknowledgment =
    PricedOrder
    AND AcknowledgmentLetter

workflow: "Place Order" =
    input: OrderForm
    output:
        OrderPlaced event
        Or InvalidOrder

    do ValidateOrder
    If order is invalid then:
        add InvalidOrder to pile
        stop

    do PriceOrder

    do SendAcknowledgmentToCustomer

    return OrderPlaced event

substep "ValidateOrder" =
    input: UnvalidatedOrder
    output: ValidatedOrder OR ValidatedError
    dependenticies: CheckProductCodeExist, CheckAddressExists

    validate ~~~~

type CardNumber = CardNumber of string
type CheckNumber = CheckNumber of int
type CustomerId = CustomerId of int

type UnitQuantity = UnitQuantity of int
type KilogramQuantity = KilogramQuantity of decimal

type Address = {
    Street: string
    City: string
    ZipCode: string
}

// 値オブジェクトの使用例
let address1 = { Street = "123 Main St"; City = "Anytown"; ZipCode = "12345" }
let address2 = { Street = "123 Main St"; City = "Anytown"; ZipCode = "12345" }

// address1 と address2 は属性が同じなので同一とみなされる
address1 = address2 // true

type CustomerId = CustomerId of int

type Customer = {
    Id: CustomerId
    Name: string
    Address: Address
}

// エンティティの使用例
let customer1 = { Id = CustomerId 1; Name = "John Doe"; Address = address1 }
let customer2 = { Id = CustomerId 2; Name = "Jane Doe"; Address = address2 }

// customer1 と customer2 は同じ属性を持っていても、異なるIDを持つため別のエンティティとみなされる
customer1 = customer2 // false

// 値オブジェクトの定義
type Address = {
    Street: string
    City: string
    ZipCode: string
}

// エンティティの定義
type OrderLine = {
    ProductId: int
    Quantity: int
    UnitPrice: decimal
}

// 集約ルートの定義
type Order = {
    Id: int
    CustomerId: int
    OrderLines: List<OrderLine>
    ShippingAddress: Address
}

// 集約ルートによる操作の実装
let addOrderLine order productId quantity unitPrice =
    let newOrderLine = { ProductId = productId; Quantity = quantity; UnitPrice = unitPrice }
    { order with OrderLines = newOrderLine :: order.OrderLines }

let updateShippingAddress order newAddress =
    { order with ShippingAddress = newAddress }

// 集約ルートの使用例
let order = { 
    Id = 1
    CustomerId = 123
    OrderLines = []
    ShippingAddress = { Street = "123 Main St"; City = "Anytown"; ZipCode = "12345" }
}

let updatedOrder = addOrderLine order 456 2 19.99M
let finalOrder = updateShippingAddress updatedOrder { Street = "456 Elm St"; City = "Othertown"; ZipCode = "67890" }

// 型定義
type CardNumber = CardNumber of string

// スマートコンストラクタ
module CardNumber =
    let create (input: string) =
        if isValidCardNumber input then
            Some (CardNumber input)
        else
            None

// バリデーション関数
let isValidCardNumber (input: string) : bool =
    input.Length = 16 && input |> Seq.forall Char.IsDigit