types-showcase.fss

type Address =
    { City: string
      Zip: int }

type User =
    { Id: int
      Name: string
      Tags: string list
      Address: Address option
      Scores: int map
      Pair: (int * string) }

type Subscription =
    | Free
    | Premium of int

type Priority =
    | Low
    | Medium
    | High

type MapShowcase =
    { ById: string map[int]
      ByFlag: string map[bool]
      ByPriority: string map[Priority] }


let scores =
    { ["math"] = 20; ["science"] = 18 }

let statusByCode =
    { ["200"] = "ok"; ["404"] = "not-found" }

let mapShowcase =
    { ById = { [1] = "first"; [2] = "second" }
      ByFlag = Map.ofList [(true, "enabled"); (false, "disabled")]
      ByPriority = Map.empty |> Map.add Low "later" |> Map.add High "now" }

let lookup_priority values = values[High]
let lookup_id values = Map.tryGet 1 values
let lookup_flag values = values[true]
let topPriority = lookup_priority mapShowcase.ByPriority |> Option.defaultValue "unknown"
let firstId = lookup_id mapShowcase.ById |> Option.defaultValue "unknown"
let enabled = lookup_flag mapShowcase.ByFlag |> Option.defaultValue "unknown"


let user = { Id = 1; Name = "Ada"; Tags = ["engineer"; "writer"]; Address = Some { City = "London"; Zip = 12345 }; Scores = scores; Pair = (7, "seven") }
let subscription = Premium 12

// Helper typed with OfficeAddress.
let make_office_address (address: Address) = address
let officeAddress = make_office_address { City = "London"; Zip = 12345 }
// Same shape as Address, inferred structurally from literal.
let parisAddress = { City = "Paris"; Zip = 75000 }


let updated = { user with Tags = user.Tags @ ["mathematician"] }

// Inline structural annotation: any record with matching fields is accepted.
let format_address (address: { City: string; Zip: int }) = $"{address.City} ({address.Zip})"

// Name exposure for host capability maps.
let capabilities =
    // Compact multiline map layout.
    { ["format_address"] = "address formatting"
      ["make_office_address"] = "office address constructor" }


let city =
    match updated.Address with
    | Some address -> address.City
    | None -> "unknown"


let mathScore =
    updated.Scores
    |> Map.tryGet "math"
    |> Option.defaultValue 0


let hasScience = updated.Scores |> Map.containsKey "science"
let formatAddressKey = "format_address"
let scienceKey = "science"
let okCode = "200"
let patchedScores = { ["science"] = 19; ..updated.Scores }

let mapPreview =
    match updated.Scores with
    | {} ->
        "empty"
    | { [subject] = score; ..remaining } ->
        $"first={subject}:{score}, remaining={Map.count remaining}"

let monthlyPrice =
    match subscription with
    | Free -> 0
    | Premium amount -> amount

let missing = "missing"
let unknown = "unknown"

Console.writeLine $"User: {updated.Name}"
Console.writeLine $"City: {city}"
Console.writeLine $"Math score: {mathScore}"
Console.writeLine $"Has 'science': {hasScience}"
Console.writeLine $"Patched science score: {patchedScores |> Map.tryGet scienceKey |> Option.defaultValue 0}"
Console.writeLine $"Map preview: {mapPreview}"
Console.writeLine $"Subscription price: {monthlyPrice}"

// Structural record equivalence showcase:
// - literal with matching fields
// - value created through another named record type (OfficeAddress)
Console.writeLine $"Structural address from literal: {format_address parisAddress}"
Console.writeLine $"Structural address from OfficeAddress: {format_address officeAddress}"
Console.writeLine $"Capability for format_address: {Map.tryGet formatAddressKey capabilities |> Option.defaultValue missing}"
Console.writeLine $"HTTP 200: {statusByCode[okCode] |> Option.defaultValue unknown}"
Console.writeLine $"Map keys: id={firstId}, bool={enabled}, union={topPriority}"


updated.Tags |> List.iter Console.writeLine


match updated with
| { Id = id; Pair = (left, right) } ->
    Console.writeLine $"Record pattern: id={id}, pair=({left}, {right})"
| _ ->
    Console.writeLine "Unexpected"