Type System¶

# Lists (homogeneous, variable length)
list<int>           # [1; 2; 3]
list<str>           # ["a"; "b"; "c"]

# Tuples (heterogeneous, fixed size)
(int, str)          # (42, "hello")
(int, str, bool)    # (1, "x", true)

# Option (represents presence or absence of a value)
option<int>         # Some 42 or None
option<str>         # Some "value" or None

# Result (represents success or failure)
result<int, str>    # Ok 42 or Error "failed"
result<str, Error>  # Ok "data" or Error { code = 1; message = "..." }

# Lazy (deferred computation with memoization)
lazy<int>           # lazy 42
lazy<str>           # lazy (computeString data)

# Types are inferred automatically
let x = 42                    # x: int
let name = "Alice"            # name: str
let items = [1; 2; 3]         # items: list<int>
let pair = (1, "hello")       # pair: (int, str)
let double = fun x -> x * 2   # double: int -> int

# Inference through usage
let add x y = x + y           # add: int -> int -> int (inferred from +)
let greet name = $"Hi, {name}"  # greet: str -> str

# Explicit annotations when needed
let count: int = 42
let ratio: float = 42.0       # Would be int without annotation
let empty: list<str> = []     # Empty list needs type hint

# Function annotations
let add (x: int) (y: int): int = x + y
let parse (s: str): result<int, str> = tryParseInt s

# Define a record type
type Person = {
    name: str
    age: int
    email: option<str>
}

# Create record instances
let alice = { name = "Alice"; age = 30; email = Some "alice@example.com" }
let bob = { name = "Bob"; age = 25; email = None }

# Access fields
let aliceName = alice.name            # "Alice"
let bobAge = bob.age                  # 25

# Copy with update (functional update)
let olderAlice = { alice with age = 31 }
let bobWithEmail = { bob with email = Some "bob@example.com" }

# Nested records
type Address = {
    city: str
    country: str
}

type Employee = {
    person: Person
    address: Address
    salary: int
}

let emp = {
    person = alice
    address = { city = "NYC"; country = "USA" }
    salary = 100000
}

# Nested access
let city = emp.address.city           # "NYC"

# Nested update
let relocated = { emp with address = { emp.address with city = "Boston" } }

# Define a union type
type Shape =
    | Circle of radius: float
    | Rectangle of width: float * height: float
    | Point

# Create instances
let c = Circle 5.0
let r = Rectangle (10.0, 20.0)
let p = Point

# Pattern match on unions
let area shape =
    match shape with
    | Circle r -> 3.14159 * r * r
    | Rectangle (w, h) -> w * h
    | Point -> 0.0

# Access named fields directly with dot notation
c.radius         # 5.0
r.width          # 10.0

# More complex union
type JsonValue =
    | JsonNull
    | JsonBool of bool
    | JsonNumber of float
    | JsonString of str
    | JsonArray of list<JsonValue>
    | JsonObject of list<(str, JsonValue)>

# Built-in unions (defined by the language)
# type option<T> = Some of T | None
# type result<T, E> = Ok of T | Error of E

# Generic union type
type Box<'a> =
    | Wrap of 'a
    | Empty

let b1 = Wrap 42       # Box<int>
let b2 = Wrap "hello"  # Box<str>

match b1 with
| Wrap x -> print x    # 42
| Empty -> print "empty"

# Multi-parameter generic union
type Either<'a, 'b> =
    | Left of 'a
    | Right of 'b

let e = Left 42
match e with
| Left x -> print x
| Right _ -> print "other"

# Generic record type
type Pair<'a, 'b> = { first: 'a; second: 'b }

let p = { first = 1; second = "hello" }
print p.first    # 1

# Recursive generic type (binary tree)
type Tree<'a> =
    | Leaf of 'a
    | Node of Tree<'a> * Tree<'a>

let t = Node (Leaf 1, Node (Leaf 2, Leaf 3))

# Tuple element access (by name or numeric index)
let pair = (42, "hello")
print (pair.fst)                      # 42
print (pair.0)                        # 42 (same as .fst)
print (pair.snd)                      # hello
print (pair.1)                        # hello (same as .snd)

let triple = (1, 2, 3)
print (triple.fst)                    # 1
print (triple.0)                      # 1 (same as .fst)
print (triple.snd)                    # 2
print (triple.1)                      # 2 (same as .snd)
print (triple.trd)                    # 3
print (triple.2)                      # 3 (same as .trd)

# Option properties
let opt = Some 42
print opt.isSome                      # true
print opt.isNone                      # false

# Result properties
let ok = Ok 100
print ok.isOk                         # true
print ok.isError                      # false

# String properties
let s = "hello"
print s.length                        # 5