Code Examples

-- This is a line comment

{- This is a
   block comment -}

let x = 42  -- inline comment

fn add: Int -> Int -> Int
fn add x y =
    x + y

add 2 3  -- Returns 5

let condition = True

if condition then
    "result1"
else
    "result2"  -- Must align with 'result1'

fn example: Int -> Int
fn example x =
    let y = 1  -- Block must be indented
    x + y

example 5

module Math exposing (add)

    fn add: Int -> Int -> Int
    fn add x y =
        x + y

-- Arithmetic
let sum = 1 + 2

let diff = 5 - 3

let prod = 4 * 2

let x = 1

let x = x + 1

x

-- Numbers
let intVal = 42  -- Int

let floatVal = 3.14  -- Float

let price = 19.99d  -- Decimal (exact precision)

let x = 42

let name = "Alice"

let pi = 3.14159

-- Prepend element
let list1 =
    1 :: [2, 3]
    -- Concatenate lists

let list2 =

-- Filter: keep matching elements
import List

[ 1
, 2
, 3

-- Fold: reduce to single value
import List

[ 1
, 2
, 3

import List

fn length: [a] -> Int
fn length list =
    case list of
        [] -> 0

let items =
    [10, 20, 30]

items[0]

-- Prepend (cons)
let consed =
    1 :: [2, 3]
    -- Concatenation

let joined =

let list =
    [1, 2, 3]

case list of
    [] -> "empty"
    [x] -> "single element"

let numbers =
    [ 1
    , 2
    , 3
    , 4
    , 5

-- Map: transform each element
import List exposing (map)

[1, 2, 3]
    |> map (|x| x * 2)  -- [2, 4, 6]

let data =
    { user = { profile = { name = "Alice" } } }

data.user.profile.name

let user =
    { name = "Alice", age = 30 }

user.name

let person =
    { name = "David", age = 40 }

let { name, age } = person

name

let person =
    { name = "Alice", age = 30 }

let updated = { person | age = 31, name = "Alicia" }

updated.name

let person =
    { name = "Bob", age = 25 }

case person of
    { name, age } -> name

let user =
    { name = "Carol", age = 35, email = "carol@example.com" }

case user of
    { name, .. } -> "Hello, " ++ name

-- Record update syntax

type alias Person = { name: String, age: Int }

let person =
    { name = "Alice", age = 30 }

let user =
    { name = "Eve", age = 28 }
    -- Update fields (creates new record)

let updatedUser = { user | age = user.age + 1 }

let user =
    { name = "Alice", age = 30, email = "alice@example.com" }

user.name

import List

fn reverse: [a] -> [a]
fn reverse list =
    case list of
        [] -> []

let pair = (1, "hello")

let first = pair.0  -- 1

let second = pair.1  -- "hello"

let triple = (True, 42, "world")

triple.2

let (x, y) = (10, 20)

x + y

let pair = (3, 0)

case pair of
    (0, 0) -> "origin"
    (x, 0) -> "on x-axis"
    (0, y) -> "on y-axis"

let pair = (1, "one")

let triple = (True, 42, "hello")

let point = (3.5, 4.2)

type Color = Red | Green | Blue

let color = Color::Green

let description =
    case color of

type Color = Red | Green | Blue

let color = Green

case color of
    Red -> "primary"

let score = 85

let grade =
    if score >= 90 then "A"
    else if score >= 80 then "B"
    else if score >= 70 then "C"

type Color = Red | Green | Blue

let color = Blue

case color of
    Red   -> "red"

let x = 0

case x of
    n if n > 0 -> "positive"
    n if n < 0 -> "negative"
    _ -> "zero"

let number = -5

case number of
    n if n < 0 -> "negative"
    n if n == 0 -> "zero"
    n if n > 0 -> "positive"

let x = 5

let result =
    if x > 0 then
        "positive"
    else

let condition = True

if condition then
    "yes"
else
    "no"

let condition = True

-- Valid: both branches return Int
if condition then
    1
else

if condition then 1 else "zero"  -- Error: type mismatch

let numbers =
    [1, 2, 3]

case numbers of
    [] -> "empty list"
    [x] -> "single element"

let maybeUser = Just "Alice"

let displayName =
    case maybeUser of
        Just name -> name
        Nothing -> "Anonymous"

type Maybe a = Just a | Nothing

let list =
    [ 1
    , 2
    , 3
    , 4
    ]

let data = (3, 4)

case data of
    (a, b) -> a + b

type Day
    = Monday
    | Tuesday
    | Wednesday
    | Thursday
    | Friday

fn sum: [Int] -> Int
fn sum list =
    case list of
        [] -> 0
        x :: xs -> x + sum xs

let parseResult = Ok 42

case parseResult of
    Ok n    -> "Parsed: " ++ show n
    Err msg -> "Error: " ++ msg

type Result a e = Ok(a) | Err(e)

-- Aggregation with DataFrame.Expr
import DataFrame
import DataFrame.Expr as Expr

DataFrame.fromRecords
    [ { value = 10 }

-- DataFrame.Expr for composable column operations
import DataFrame
import DataFrame.Expr as Expr

DataFrame.fromRecords
    [ { name = "Alice", revenue = 100 }

-- Conditional expressions with DataFrame.Expr
import DataFrame
import DataFrame.Expr as Expr

DataFrame.fromRecords
    [ { name = "Alice", score = 95 }

-- String operations with DataFrame.Expr
import DataFrame
import DataFrame.Expr as Expr

DataFrame.fromRecords
    [ { name = "alice" }

-- Track data transformation history
import DataFrame

-- Create data and track transformations
DataFrame.fromRecords [{ product = "Laptop", revenue = 1200 }, { product = "Phone", revenue = 800 }]
    |> DataFrame.filterGt "revenue" 700

-- Remap values with automatic label transfer
import DataFrame

let df =
    DataFrame.fromRecords
        [ { id = 1, score = 1 }

-- Attach value labels for coded variables
import DataFrame
import ValueLabelSet

let gender = ValueLabelSet.fromList [(1, "Male"), (2, "Female")]

-- Variable labels for column descriptions
import DataFrame

let df =
    DataFrame.fromRecords
        [ { id = 1, gender = 1 }

-- SQL-style window functions
import DataFrame

-- Sample sales data and window functions
DataFrame.fromRecords [{ product = "Laptop", revenue = 1200 }, { product = "Phone", revenue = 800 }]
    |> DataFrame.withColumn "rank" [1, 2]

-- Date arithmetic
import Date

let date = case Date.fromYmd 2024 3 15 of
    Ok d -> d
    Err _ -> Date.today ()

-- Comparing dates and computing differences
import Date

let start = case Date.fromYmd 2024 1 1 of
    Ok d -> d
    Err _ -> Date.today ()

-- Extracting date components
import Date

let date = case Date.fromYmd 2024 3 15 of
    Ok d -> d
    Err _ -> Date.today ()

-- Creating dates from year, month, day
import Date

Date.fromYmd 2024 3 15

-- Parsing dates from strings
import Date

Date.parseIso "2024-06-15"

-- Combine Date and Time into DateTime
import DateTime
import Date
import Time

let date = case Date.fromYmd 2024 6 15 of

-- Convert Date to DateTime at midnight UTC
import DateTime
import Date

let date = case Date.fromYmd 2024 1 1 of
    Ok d -> d

-- Extract Date component from DateTime
import DateTime
import Date

let dt = case DateTime.fromDate 2024 6 15 of
    Just d -> d

-- Extract Time component from DateTime
import DateTime
import Time

let dt = case DateTime.fromParts 2024 6 15 14 30 0 of
    Just d -> d

-- Decimal comparison and checks
import Decimal

let a = 10.5d
let b = 3.2d

-- Converting between Decimal and other types
import Decimal

let price = 19.99d

-- Convert to string

-- Decimal literals use the 'd' suffix
import Decimal

let price = 19.99d
let taxRate = 0.073d

-- Parse a string into a Decimal
import Decimal

Decimal.parse "42.5"

-- Rounding decimals to specific precision
import Decimal

let price = 19.99d
let taxRate = 0.073d
let total = price + price * taxRate

-- Duration arithmetic
import Duration

let oneHour = Duration.fromHours 1
let thirtyMin = Duration.fromMinutes 30

-- Duration comparison and checks
import Duration

let d = Duration.fromMinutes 90

Duration.isPositive d

-- Converting between duration units
import Duration

let d = Duration.fromMinutes 150

-- Get total hours (truncated)

-- Creating and converting durations
import Duration

let twoHours = Duration.fromHours 2

Duration.toSeconds twoHours

if condition then
    result1
  else         -- Error: 'else' must align with 'if'
    result2

let x =
x + 1          -- Error: Block must be indented more than parent
               -- Hint: Indent the block to 4 spaces

let x = True

let y = False

x && y

let x = true     -- Error: 'true' is not a Keel keyword
                 -- Hint: Use `True` for boolean true

let items =
    [1, 2, 3]

items[10]  -- Error: Index 10 out of bounds for list of size 3

let items =
    [1, 2, 3]

items[0]  -- 1

let x = 2

case x of
    1 -> "one"
    2 -> "two"
    _ -> "other"

case x of
    1 -> 42        -- Int
    2 -> "hello"   -- Error: Case branches have incompatible types: Int and String
    _ -> 0

case Just 5 of
    Ok n -> n  -- Error: Pattern type mismatch: expected Maybe, but pattern is Result (Ok)
    _ -> 0

fn double: Int -> Int
fn double x =
    x * 2
    -- Pattern matching uses case...of

let value = Just 5

type Direction = North | south    -- Error: Enum variant must start with uppercase

let userName = "Alice"
let userAge = 30
let userEmail = "alice@example.com"
print usrNme
-- Error: Variable 'usrNme' is not declared. Did you mean 'userName', 'userAge', or 'userEmail'?

let userName = "Alice"
let userAge = 30
print usrName
-- Error: Variable 'usrName' is not declared. Did you mean 'userName'?

let x = 5

case x of
    n if n > 0 -> "positive"
    n if n < 0 -> "negative"
    _ -> "zero"

case x of
    n if n + 1 -> "bad"    -- Error: Guard expression must be Bool, found Int
    _ -> "ok"

fn example x =
let y = 1    -- Error: Expected indentation of at least 4 spaces
    x + y

{ name: "Alice", age: 30 }
-- Error: JavaScript-style record syntax is not allowed
-- Hint: Use `=` instead of `:` for record field assignment
-- Example: `{ name = "Alice" }`

return 5         -- Hint: Keel is expression-based; the last expression is the return value
match x of       -- Hint: Use `case ... of` for pattern matching
function add     -- Hint: Use `fn` to define functions
var x = 5        -- Hint: Use `let` for variable bindings

let present = Just 42

let absent = Nothing

case present of
    Just n -> "Got a value"

-- Safe error handling with Maybe
import List

import Maybe

-- Extract values with default fallback

let x = null     -- Error: 'null' is not a Keel keyword
                 -- Hint: Use `Nothing` for absent values

case 42 of
    "hello" -> 1  -- Error: Pattern type mismatch: expected Int, but pattern is String
    _ -> 0

{ name = "Alice", age = 30 }

let x =
    let inner = 5
    inner
print inner    -- Error: Variable 'inner' is not in scope

fn add: Int -> Int -> Int
fn add x y =
    x + y

add "hello" 5  -- Error: Expected Int but got String

let x = unknownVar    -- Error: Variable 'unknownVar' is not declared

module Math exposing (..)

    fn add: Int -> Int
    fn add x =
        x + 1

module Math exposing (..)

    fn add: Int -> Int
    fn add x =
        x + 1

fn greet: String -> String
fn greet name =
    "Hello, " ++ name ++ "!"

greet "Alice"  -- "Hello, Alice!"

fn factorial: Int -> Int
fn factorial n =
    if n <= 1 then
        1
    else
        n * factorial (n - 1)

fn factorial: Int -> Int
fn factorial n =
    case n of
        0 -> 1
        1 -> 1
        _ -> n * factorial (n - 1)

fn fibonacci: Int -> Int
fn fibonacci n =
    if n <= 1 then
        n
    else
        fibonacci (n - 1) + fibonacci (n - 2)

-- Takes a function as argument
fn applyTwice: (Int -> Int) -> Int -> Int
fn applyTwice f x =
    f (f x)

applyTwice (|x: Int| x + 1) 5  -- 7

module M exposing (..)

    fn apply: (Int -> Int) -> Int -> Int
    fn apply f x =
        f x

module Apply exposing (..)

    fn apply: (Int -> Int) -> Int -> Int
    fn apply f x =
        f x

module Math exposing (..)

    fn double: Int -> Int
    fn double x =
        x * 2

module Math exposing (..)

    fn double: Int -> Int
    fn double x =
        x * 2

fn inc: Int -> Int
fn inc x =
    x + 1

fn inc: Float -> Float
fn inc x =

fn double: Int -> Int
fn double x =
    x * 2

fn addOne: Int -> Int
fn addOne x =

-- Pipe operator provides context from the left operand
5
    |> |x| x + 1

import List

-- Type inference flows through chained operations
-- Each lambda's parameter type is inferred from the previous result
[ 1
, 2

import List

-- Lambda parameter type inferred from List.filter signature
List.filter (|x| x > 2)

[ 1

import List

-- Accumulator and element types inferred from List.foldl signature
-- foldl : (b -> a -> b) -> b -> List a -> b
-- With initial value 0 (Int) and List Int, acc : Int and x : Int
List.foldl (|acc x| acc + x)

import List

-- Lambda parameter type inferred from List.map signature
List.map (|x| x * 2)

[1, 2, 3]

import List

-- Both parameters inferred from List.zipWith signature
-- zipWith : (a -> b -> c) -> List a -> List b -> List c
-- With List Int and List Int, both x : Int and y : Int
List.zipWith (|x y| x * y)

fn add: Int -> Int -> Int
fn add x y =
    x + y

add 3 4  -- 7

-- Simple Result handling
case Ok "success" of
    Ok data -> data
    Err msg -> "error"

-- Function body must be indented
fn addOne : Int -> Int
fn addOne x =
    x + 1

addOne 5  -- 6

-- Case branches must be indented from 'case'
let value = 2

let result = case value of
    1 -> "one"
    2 -> "two"

-- Case branch bodies can span multiple lines
let value = 2

let result = case value of
    1 ->
        let x = 10

-- Multiline arguments work with COLLECTIONS (lists, records, tuples)
-- NOT with simple values like integers

import List

-- This works: list on new indented line continues as argument

-- If-then-else branches with multiline bodies
let condition = True

let result =
    if condition then
        let a = 1

-- Multiple let bindings at same indentation form a block
fn compute : Int -> Int
fn compute x =
    let a = x + 1
    let b = a * 2
    let c = b - 3

-- Lists can span multiple lines (Elm-style)
import List

let numbers =
    [ 1
    , 2

-- Multi-line function calls work with collections on new lines
import List

-- Lambda on same line, list on indented new line
let doubled = List.map (|x| x * 2)
    [ 1

-- Pipes work naturally with multiline formatting
import List

let result = [1, 2, 3, 4, 5]
    |> List.map (|x| x * 2)
    |> List.filter (|x| x > 4)

-- Records can span multiple lines (Elm-style)
let person =
    { name = "Alice"
    , age = 30
    , city = "Paris"
    }

-- Indentation creates nested scopes within a block
fn example : Int -> Int
fn example x =
    let a = x + 1
    let b = a * 2      -- 'a' is visible here
    let c = a + b      -- both 'a' and 'b' are visible

-- Lines at the SAME indentation are separate expressions
let x = 1
let y = 2
let z = 3

-- Each let is a separate statement, evaluated in sequence

-- Automatic data lineage tracking
import DataFrame

let sales =
    DataFrame.fromRecords
        [ { product = "Laptop", revenue = 1200 }

-- List operations with pipes
import List

let numbers =
    [ 1
    , 2

-- Pipe operator for data flow
import String

let result =
    "hello"
        |> String.toUpper

-- Maybe type for safe operations
import String

fn safeDivide: Float -> Float -> Maybe Float
fn safeDivide num denom =
    if denom == 0.0 then

-- Define a custom type
type Result a e = Ok(a) | Err(e)

-- Record with type alias

type alias Person = { name: String, age: Int }

module Math exposing (add, multiply)

    fn add: Int -> Int -> Int
    fn add x y =
        x + y

module Math exposing (multiply)

    fn multiply: Int -> Int -> Int
    fn multiply x y =
        x * y

-- Expose specific items
module exposing (functionA, functionB, TypeA)

-- Expose all
module exposing (..)

module Math exposing (fibonacci)

    fn fibonacci: Int -> Int
    fn fibonacci n =
        if n <= 1 then n
        else fibonacci (n - 1) + fibonacci (n - 2)

module exposing (User, createUser, getName)

type alias User = { name: String, age: Int }

fn createUser : String -> Int -> User
fn createUser name age = { name = name, age = age }

module Geometry exposing (Shape, area, perimeter)

    import Math

    type Shape = Circle(Float) | Rectangle(Float, Float) | Triangle(Float, Float, Float)

module Geometry exposing (perimeter)

    fn perimeter: Float -> Float
    fn perimeter r =
        2.0 * 3.14159 * r

import String

import Math as Something

-- Modules and import aliases
import Math as M

import List as L

M.abs (L.length [1, 2, 3])

import List exposing (map)

-- Using built-in list functions directly
[1, 2, 3]
    |> map (|x| x * 2)  -- [2, 4, 6]

module Math exposing (add)

    fn add: Int -> Int -> Int
    fn add x y =
        x + y

-- Error: Inline module content must be indented
module Math exposing (add)

fn add x y = x + y    -- Wrong: not indented

module Math exposing (add, multiply)

    fn add: Int -> Int -> Int
    fn add x y =
        x + y

module Math exposing (factorial, fibonacci)

    fn factorial: Int -> Int
    fn factorial n =
        if n <= 1 then 1
        else n * factorial (n - 1)

let addition = 5 + 3

let subtraction = 10 - 4

let multiply = 6 * 7

let eq = 5 == 5

let neq = 5 != 6

let lt = 3 < 5

-- Backward composition (g first, then f)
let addOne = |x: Int| x + 1

let double = |x: Int| x * 2

let doubleThenAdd = addOne << double

-- Forward composition (f first, then g)
let addOne = |x: Int| x + 1

let double = |x: Int| x * 2

let addThenDouble = addOne >> double

let floatDiv = 10 / 3

let intDiv = 10 // 3

(floatDiv, intDiv)

-- Cons (prepend element)
let consed1 =
    1 :: [2, 3]

let consed2 : List Int = 1 :: (2 :: [])

-- And (both must be True)
let and1 = True && True

let and2 = True && False

-- Or (at least one must be True)

fn double: Int -> Int
fn double x =
    x * 2

fn addOne: Int -> Int
fn addOne x =

import List

-- Pipeline example
[ 1
, 2
, 3

-- False && ... returns False immediately without evaluating the right side
let result = False && True

result  -- False

"Hello, " ++ "World!"

let x = 1 + 2.5

let y = 3 * 1.5

x + y

let maybe = Just 42

case maybe of
    Just x as original -> (x, original)
    Nothing -> (0, Nothing)

let list =
    [1, 2, 3]

case list of
    x :: xs as all -> "Head"
    [] -> "empty"

case x of
    1 -> 42        -- Int
    2 -> "hello"   -- Error: Case branches have incompatible types
    _ -> 0

let list =
    [1, 2, 3]

case list of
    x :: xs -> x  -- x is the head, xs is the tail
    [] -> 0  -- empty list case

let maybeValue = Just 42

case maybeValue of
    Just x -> "Got value"
    Nothing -> "Nothing"

type TrafficLight = Red | Yellow | Green

let light = TrafficLight::Yellow

case light of
    TrafficLight::Red -> "stop"

fn addPairs: (Int, Int) -> (Int, Int) -> (Int, Int)
fn addPairs p1 p2 =
    case (p1, p2) of
        ((x1, y1), (x2, y2)) -> (x1 + x2, y1 + y2)

addPairs

fn fst: (a, b) -> a
fn fst pair =
    case pair of
        (x, _) -> x

fst

let x = 0

case x of
    n if n > 0 -> "positive"
    n if n < 0 -> "negative"
    _ -> "zero"

let number = 42

case number of
    n if n < 0 -> "negative"
    n if n == 0 -> "zero"
    n if n < 10 -> "small positive"

-- Record destructuring
let describe =
    |{ name: String, age: Int }| name

describe { name = "Bob", age = 25 }

-- Tuple destructuring
let addPair = |(x: Int, y: Int)| x + y

addPair

(3, 4)  -- 7

let user =
    { name = "Alice", age = 30 }

let { name, age } = user

name

let point = (10, 20)

let (x, y) = point

x + y

let list =
    [1, 2]

case list of
    [] -> "empty"
    [x] -> "single"

let x = 1

case x of
    0 -> "zero"
    1 -> "one"
    _ -> "many"

let list =
    [ 1
    , 2
    , 3
    , 4
    ]

import String

let result = Ok (Just 5)

case result of
    Ok (Just x) -> "Success with value: " ++ String.fromInt x

let point = (5, 2)

case point of
    (x, 1) | (x, 2) | (x, 3) -> x  -- x is bound in all alternatives
    _ -> 0

type Direction
    = North
    | South
    | East
    | West

let person =
    { name = "Alice", age = 30 }

case person of
    { name, age } -> name

let user =
    { name = "Bob", age = 25, email = "bob@example.com" }

case user of
    { name, .. } -> "Hello, " ++ name

fn sum: [Int] -> Int
fn sum numbers =
    case numbers of
        [] -> 0
        x :: xs -> x + sum xs

let pair = (3, 0)

case pair of
    (0, 0) -> "origin"
    (x, 0) -> "on x-axis"
    (0, y) -> "on y-axis"

case 42 of
    "hello" -> 1  -- Error: Pattern type mismatch: expected Int, but pattern is String
    _ -> 0

let x = 2

case x of
    1 -> 42  -- Int
    2 -> 3.14  -- Float: compatible, unifies to Float
    _ -> 0

let x = False

case x of
    _ -> "anything"  -- This matches everything
    True -> "true"  -- Warning: Unreachable pattern

let point = (3, 4)

case point of
    (x, y) -> x + y

let tuple = (42, "ignored")

case tuple of
    (x, _) -> x  -- Ignore second element

-- Builder pattern for custom tables
import DataFrame
import Table

DataFrame.fromRecords
    [ { region = "North", sales = 100 }

-- Two-way cross-tabulation
import DataFrame
import Table

DataFrame.fromRecords
    [ { gender = "M", group = "A" }

-- One-way frequency table
import DataFrame
import Table

DataFrame.fromRecords
    [ { category = "A" }

-- Summary statistics by group
import DataFrame
import Table

DataFrame.fromRecords
    [ { region = "North", sales = 100 }

-- Time arithmetic
import Time

let t = case Time.fromHms 14 30 0 of
    Ok t -> t
    Err _ -> Time.midnight ()

-- Extracting time components
import Time

let t = case Time.fromHms 14 30 0 of
    Ok t -> t
    Err _ -> Time.midnight ()

-- Creating time values
import Time

Time.fromHms 14 30 0

-- Parsing time from strings
import Time

Time.parseIso "09:15:30"

type alias UserId = Int

let x = 42  -- UserId resolves to Int

let y = x  -- Compatible: UserId is Int

-- Case expression patterns
case (42, "test") of
    (x, y) -> y

-- List of integers
let numbers =
    [1, 2, 3]
    -- Tuple

let pair = (42, "answer")

-- Compile-time schema validation
import DataFrame

-- Create typed data
DataFrame.fromRecords [{ name = "Alice", age = 30 }, { name = "Bob", age = 25 }]
    |> DataFrame.select ["name", "age"]

type Pair a b = Pair a b

let p = Pair 1 "hello"
p

type Tree a
    = Leaf a
    | Node (Tree a) a (Tree a)

let tree: Tree Int =
    Node

-- Higher-order function context
[1, 2, 3] |> map (|x| x * 2)  -- x inferred as Int from list context

let x = 42  -- Inferred as Int

let name = "Alice"  -- Inferred as String

let ratio = 3.14  -- Inferred as Float

let empty: List Int = []  -- Needed: can't infer element type
length empty

|x| x + 1

|x: Int| x + 1

-- Lambda parameter patterns with context
(1, 2)
    |> |(a, b)| a + b

type Maybe a = Just a | Nothing

let present = Just 42

let absent = Nothing

case present of
    Just n -> "Got a value"

type Direction
    = North
    | South
    | East
    | West

let x = 1 + 2.5

let y = 3 * 1.5

x + y

type alias Container a = { value: a }

let intBox =
    { value = 42 }

intBox.value

-- Pipe operator provides context
5
    |> |x| x + 1

let x = 42

let pi = 3.14

let active = True

type alias User = {
    id: Int,
    name: String,
    email: String,
    active: Bool
}

type MyList a = Nil | Cons a (MyList a)

let nums = Cons 1 (Cons 2 (Cons 3 Nil))
nums

let failure = Err "something went wrong"

case failure of
    Ok value -> "Success"
    Err msg -> "Error: " ++ msg

let success = Ok 42

case success of
    Ok value -> "Success"
    Err msg -> "Error: " ++ msg

type Result a e = Ok a | Err e

type Direction = North | South | East | West

let heading = North
heading

-- Tuple destructuring
let pair = (1, "hello")

let (x, y) = pair  -- x: Int, y: String

y

type alias Name = String

type alias Age = Int

let userName = "Bob"

type Direction = North | South | East | West

let favorite: Direction = North

case favorite of
    North -> "Going up"

type Shape
    = Circle Float
    | Rectangle Float Float

fn area : Shape -> Float
fn area shape = case shape of

type Shape
    = Circle Float
    | Rectangle Float Float

fn area : Shape -> Float
fn area shape = case shape of

type User
    = Guest
    | Member { name: String, id: Int }

let user = Member { name = "Alice", id = 42 }

-- Check which values lack labels
import ValueLabelSet

let labels = ValueLabelSet.fromList [(1, "Agree"), (2, "Disagree")]
let result = ValueLabelSet.coverage [1, 2, 3] labels
result.unlabeled

-- Create a value label set and look up labels
import ValueLabelSet

let gender = ValueLabelSet.fromList [(1, "Male"), (2, "Female")]
ValueLabelSet.getLabel 1 gender

-- Merge two label sets and check size
import ValueLabelSet

let base = ValueLabelSet.fromList [(1, "Low"), (2, "Medium")]
let extra = ValueLabelSet.fromList [(3, "High")]

-- Reverse lookup: find the code for a label
import ValueLabelSet

let gender = ValueLabelSet.fromList [(1, "Male"), (2, "Female")]
ValueLabelSet.getValue "Female" gender

let data = getRawData ()
let data = parseData data
let data = validateData data
-- each step shadows the previous binding

let name = "Alice"

let age = 30

let pi = 3.14159

let x = 10

let x = 20  -- Error: Cannot reassign variable 'x'

let area =
    let width = 10
    let height = 5
    width * height

area  -- 50

let x = 1

let y = 2

let z = 3

let (x, { a, b }) =
    (1, { a = 2, b = 3 })

a  -- 2

let { name, age } =
    { name = "Bob", age = 25 }

name  -- "Bob"

let outer = 1

let result =
    let inner = 2  -- Only accessible in this block
    outer + inner

let x = 10

let x = x + 5

x  -- 15

let x = 1

let x = x + 1

let x = "hello"  -- x can change type when shadowed

let (x, y) = (10, 20)

x  -- 10

let count = 42

let message = "Hello"

let ratio = 0.75