Code Examples

-- This is a line comment

{- This is a
   block comment -}

let x = 42  -- inline comment

{-| Increments a number by one. -}
fn inc : Int -> Int
fn inc x =
    x + 1

inc 1

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 CustomMath 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

let xs : [Int] = [1, 2, 3]

let ys : [Int] = [4, 5, 6]

ys

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

let list2 = [1, 2] ++ [3, 4]

import DataFrame

DataFrame.fromRecords
    [ { name = "Alice", score = 95 }
    , { name = "Bob", score = 87 }
    , { name = "Charlie", score = 92 }

-- Filter: keep matching elements
import List

[1, 2, 3, 4] |> List.filter (|x| x > 2)

-- [3, 4]

-- Fold: reduce to single value
import List

[1, 2, 3, 4] |> List.foldl (|acc x| acc + x) 0

-- 10

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 = [1, 2] ++ [3, 4]

let list = [1, 2, 3]

case list of
    [] -> "empty"
    [x] -> "single element"
    x :: xs -> "has multiple elements"

-- List statistics: mean, median, variance, std, percentile, mode
import List
import Maybe

-- Integer list statistics
let scores = [60, 70, 80, 90, 100]

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

let names = ["Alice", "Bob", "Charlie"]

let empty : [Int] = []

-- Map: transform each element
import List exposing map

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

let users =
    [ { name = "Alice", age = 30 }
    , { name = "Bob", age = 25 }
    , { name = "Charlie", age = 35 }
    ]

let config =
    { host = "localhost"
    , port = 8080
    , debug = True
    , maxConnections = 100
    }

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"
    }

-- Record update syntax

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

let older = { person | age = 31 }

-- Record update creates a new record
let user = { name = "Eve", age = 28 }

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

updatedUser.name

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

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)

enum Color = Red | Green | Blue

let color = Color::Green

let description =
    case color of

enum Color = Red | Green | Blue

let color = Color::Green

case color of
    Color::Red -> "primary"

let score = 85

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

enum Color = Red | Green | Blue

let color = Color::Blue

case color of
    Color::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 False then
    1
else
    "zero"  -- Error: type mismatch

let numbers = [1, 2, 3]

case numbers of
    [] -> "empty list"
    [x] -> "single element"
    [x, y] -> "two elements"

let maybeUser = Just "Alice"

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

-- norun
enum Maybe a = Just(a) | Nothing

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

case list of
    a :: b :: rest -> a + b
    x :: xs -> x
    [] -> 0

let data = (3, 4)

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

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

enum Color = Red | Green | Blue

let color = Color::Green

case color of
    Color::Red -> "fire"

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

import String

let parseResult = Ok 42

case parseResult of
    Ok n -> "Parsed: " ++ String.fromInt n

-- norun
enum Result a e = Ok(a) | Err(e)

import DataFrame

enum Country
    = Germany
    | BurkinaFaso "Burkina Faso"
    | UnitedKingdom "United Kingdom"

import DataFrame

enum Region
    = NorthEast "North East"
    | NorthWest "North West"
    | Midlands

import DataFrame

enum Education = Primary | Secondary | Tertiary | Postgraduate

let survey : DataFrame {
    respondent_id: Int,

import DataFrame

enum City = Berlin | Munich | Hamburg
enum Gender = Male | Female | Other

let data : DataFrame { city: City, gender: Gender, .. } = DataFrame.readCsv "demographics.csv"

import DataFrame

enum YesNo = No | Yes

let data : DataFrame {
    response: [(0, YesNo::No), (1, YesNo::Yes), ..]

import DataFrame

enum Status = Active | Inactive | Pending

let exact : DataFrame { id: Int, name: String, status: Status } = DataFrame.readCsv "users.csv"

-- norun

import DataFrame

enum Employment
    = Employed        (ValueLabel 1 "Employed")

import DataFrame

enum City = Berlin | Munich | Hamburg

let data : DataFrame { name: String, city: City, .. } = DataFrame.readCsv "users.csv"

import DataFrame

enum AgeGroup
    = Under18 "Under 18"
    | Young "18-34"
    | Middle "35-54"

-- norun

import DataFrame

enum Education
    = Primary     (ValueLabel 1 "Primary")

import DataFrame
import ValueLabelSet

enum Education
    = Primary (ValueLabel 1 "Primary")
    | Secondary (ValueLabel 2 "Secondary")

import DataFrame

-- Pearson correlation matrix
let data =
    DataFrame.fromRecords
        [ { x = 1, y = 2 }

import DataFrame

-- Spearman rank correlation matrix (robust to outliers and non-linear monotone relationships)
let data =
    DataFrame.fromRecords
        [ { x = 1, y = 2 }

import DataFrame

-- Multiple quantiles in one call
let data =
    DataFrame.fromRecords
        [ { score = 78 }

import DataFrame

-- Column-wise descriptive statistics
let data =
    DataFrame.fromRecords
        [ { score = 78 }

-- Aggregation with DataFrame.Expr
import DataFrame

import DataFrame.Expr as Expr

DataFrame.fromRecords

-- Pipe-style arithmetic: Expr.mul for column * column
import DataFrame
import DataFrame.Expr exposing col
import Result

import DataFrame.Expr as Expr

-- DataFrame.Expr for composable column operations
import DataFrame
import DataFrame.Expr exposing col
import Result

import DataFrame.Expr as Expr

-- Outer-scope variables are captured in expressions
import DataFrame
import Result

import DataFrame.Expr as Expr

-- Multi-branch conditional with Expr.cond
import DataFrame
import Result

import DataFrame.Expr as Expr

-- Pipe-style comparison: Expr.gte for column >= literal
import DataFrame
import DataFrame.Expr exposing col
import Result

import DataFrame.Expr as Expr

import DataFrame
import Result

import DataFrame.Expr as Expr

let full = Expr.concatMany " " [@first, @last]

-- Conditional expressions with DataFrame.Expr
import DataFrame
import DataFrame.Expr exposing col, lit
import Result

import DataFrame.Expr as Expr

import DataFrame

-- Running sum per region using window functions
DataFrame.fromRecords
    [ { region = "East", revenue = 100 }
    , { region = "East", revenue = 200 }

import DataFrame

-- Cumulative sum and mean per region using window functions
DataFrame.fromRecords
    [ { region = "East", revenue = 100 }
    , { region = "East", revenue = 200 }

import DataFrame
import DataFrame.Expr exposing col, lit
import Result

import DataFrame.Expr as Expr

import DataFrame
import DataFrame.Expr exposing col
import Result

import DataFrame.Expr as Expr

import DataFrame
import DataFrame.Expr exposing col
import Result

import DataFrame.Expr as Expr

-- Simple if/else conditional with Expr.cond
import DataFrame
import Result

import DataFrame.Expr as Expr

import DataFrame
import Result

import DataFrame.Expr as Expr

let source =

-- Membership test: Expr.in filters rows where the column value is in a list
import DataFrame
import Result

import DataFrame.Expr as Expr

-- Infix arithmetic operators work directly on column references
import DataFrame
import Result

import DataFrame.Expr as Expr

-- Boolean logic: && and || work with Expr values
import DataFrame
import Result

let df =
    DataFrame.fromRecords

-- Chained infix operations respect operator precedence
import DataFrame
import Result

import DataFrame.Expr as Expr

-- Infix comparison operators produce boolean Expr for filtering
import DataFrame
import Result

let df =
    DataFrame.fromRecords

-- Scalars are auto-coerced to Expr when used with infix operators
import DataFrame
import Result

import DataFrame.Expr as Expr

-- Math functions: abs
import DataFrame
import Result

import DataFrame.Expr as Expr

-- Add a computed column with applyExprs using tuple syntax
import DataFrame
import Result

import DataFrame.Expr as Expr

-- Null handling: fillNull
import DataFrame
import DataFrame.Expr exposing col
import Result

import DataFrame.Expr as Expr

-- Operators work directly on column references
import DataFrame
import Result

import DataFrame.Expr as Expr

import DataFrame

import DataFrame.Expr as Expr

-- Interquartile range components
let q1 =

-- Extract year from date strings using regex capture
import DataFrame
import Result

import DataFrame.Expr as Expr

import DataFrame
import Result

import DataFrame.Expr as Expr

let revenue = @price * @qty

import DataFrame

-- Rolling window operations using partitionBy + withRollingSum/withRollingMean
DataFrame.fromRecords
    [ { region = "East", value = 1 }
    , { region = "East", value = 2 }

import DataFrame

-- 7-day rolling average using window functions
DataFrame.fromRecords
    [ { dept = "East", sales = 10 }
    , { dept = "East", sales = 20 }

import DataFrame
import DataFrame.Expr exposing col
import Result

import DataFrame.Expr as Expr

import DataFrame
import Result

import DataFrame.Expr as Expr

-- Whitespace trimming (both sides)

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

import DataFrame.Expr as Expr

-- String transformation chain
import DataFrame
import DataFrame.Expr exposing col
import Result

import DataFrame.Expr as Expr

-- @name column references work directly with infix operators
import DataFrame
import Result

import DataFrame.Expr as Expr

import DataFrame
import DataFrame.Expr exposing col
import Result

import DataFrame.Expr as Expr

import DataFrame
import Result

import DataFrame.Expr as Expr

let df =

import DataFrame
import DataFrame.Expr exposing col
import List

import DataFrame.Expr as Expr

-- norun
-- Lineage appears automatically when printing a DataFrame
import DataFrame
import DataFrame.Expr as Expr
import Result

-- lineageById looks up a DataFrame in the lineage registry by its UUID
import DataFrame
import Maybe

let df =
    DataFrame.fromRecords

-- lineageByName searches the registry by name prefix, returns a list
import DataFrame
import List

-- lineageByName returns [Record] — empty list if no match
List.length (DataFrame.lineageByName "nonexistent-name")

-- norun
-- DataFrame.columnLineage returns origin info for a column
import DataFrame

let df = DataFrame.fromRecords [{ name = "Alice", age = 30 }]

-- Join produces two parents in the DAG
import DataFrame
import List

let users =
    DataFrame.fromRecords

-- norun
-- Full lineage record structure
import DataFrame
import DataFrame.Expr as Expr
import Result

-- norun
-- Global operations (filter, sort) are tracked separately
import DataFrame

let df =
    DataFrame.fromRecords

-- norun
-- Joined columns track their source DataFrame
import DataFrame

let users =
    DataFrame.fromRecords

-- Derived DataFrames track parent operations
import DataFrame
import List
import Result

let df =

-- Root DataFrames have no parents
import DataFrame

let df = DataFrame.fromRecords [{ name = "Alice", age = 30 }]

DataFrame.parents df

-- norun
-- After rename, the transformation tracks the operation
import DataFrame
import Result

let df = DataFrame.fromRecords [{ name = "Alice", age = 30 }]

-- DataFrame.sourcePath returns Nothing for fromRecords
import DataFrame

let df =
    DataFrame.fromRecords
        [ { name = "Alice", age = 30 }

-- Track data transformation history
import DataFrame
import DataFrame.Expr as Expr
import Result

-- Create data and track transformations

-- norun
-- Columns track their transformation history
import DataFrame
import Result

let df =

-- melt reshapes wide data into long form by parsing column name prefixes
import DataFrame

-- Wide table: each measurement variable has one column per time point
let wide = DataFrame.fromRecords
    [ { nr = 1, var1_year1 = 10, var1_year2 = 20, var2_year1 = 5, var2_year2 = 8 }

-- readCsvColumns reads only the specified columns from a CSV file
import DataFrame

case DataFrame.readCsvColumns [@name, @birth_date] "content/examples/guide/dataframe/dates.csv" of
    Ok df -> DataFrame.columns df
    Err _ -> []

-- 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 with rank column
DataFrame.fromRecords
    [ { product = "Laptop", revenue = 1200, rank = 1 }

-- applyExprs batches exprs so later ones can reference columns added earlier
import DataFrame
import Result

import DataFrame.Expr as Expr

import DataFrame

let path = "data.csv"
let dir = "data/"

let a : DataFrame { name: String, .. } =

import DataFrame

let data : DataFrame { name: String, age: Int, city: String } =
    case DataFrame.readCsv "users.csv" of
        Ok df -> df
        Err _ -> DataFrame.fromRecords []

import DataFrame

type alias Row = { x : Int, y : String }

let rows : [Row] =
    [ { x = 1, y = "a" }

-- Date arithmetic
import Date

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

-- Comparing dates and computing differences
import Date

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

-- Extracting date components
import Date

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

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

Date.fromYmd 2024 3 15

import Date

-- Invalid date returns a typed error
case Date.fromYmd 2024 2 30 of
    Ok date -> Date.toIsoString date
    Err _ -> "Invalid day for this month"

-- Parsing dates from strings
import Date

Date.parseIso "2024-06-15"

import Date

-- Custom format
Date.parse "15/06/2024" "%d/%m/%Y"

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

let date =

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

let date =
    case Date.fromYmd 2024 1 1 of

import Date
-- Extract Date component from DateTime
import DateTime

let dt =
    case DateTime.fromYmd 2024 6 15 of

-- Extract Time component from DateTime
import DateTime
import Time

let dt =
    case DateTime.fromParts 2024 6 15 14 30 0 of

-- 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

-- 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

import List

List.map 42 [1, 2, 3]

-- Error: Type mismatch: expected (a -> b), found Int

import String

String.length 42

-- Error: Type mismatch: expected String, found Int

if True then
    0
  else         -- Error: 'else' must align with 'if'
    1

fn greet : String -> String
fn greet name =
"Hello, " ++ name   -- Error: body must be indented by at least 4 spaces

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"

let x = 2

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

import Result

-- Maybe to Result (with error message)
let a = Just 5 |> Result.fromMaybe "was nothing"

-- Result to Maybe (discards error)

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

-- Pattern matching uses case...of

let x = 10
let result =
    if x > 5 then "big"
        else "small"   -- Error: else must align with if

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

fn double x =        -- Error: missing type signature
    x * 2

import IO exposing print

let userName = "Alice"

let userAge = 30

import IO exposing print

let userName = "Alice"

let userAge = 30

import Json

let data = Json.parse "{\"x\": 1}"

-- Error: Generic function result requires a type annotation for variable 'data'

let x = 5

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

let x = 2

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

fn example : Int -> Int
fn example x =
let y = 1    -- Error: Function body must be indented by 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" }`

import Json

let data : Result { x : Int } String = Json.parse "{\"x\": 1}"

data

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"

import Maybe

-- Transform present values
let mapped = Just 5 |> Maybe.map (|x| x * 2)

-- Chain operations that might return Nothing

let x = [1, 2)
-- Error: Mismatched delimiter — '(' expected ')' but found ')'

import List
List.fold [1, 2, 3] 0
-- Error: Function 'fold' is not declared in module 'List'. Did you mean 'foldl' or 'foldr'?

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 }

import Result

-- Transform success values
let mapped : Result Int String = Ok 5 |> Result.map (|x| x * 2)

-- Chain operations that might fail

fn example : Int -> Int
fn example x =
    let inner = x + 1
    inner

inner  -- Error: Variable 'inner' is not in scope

-- Unwrap Ok with ?, short-circuit on Err
let addOne = |x: Int| Ok (x + 1)
let result = 5 |> addOne
result?

-- When ? is applied to Err, the result is Err (short-circuit)
let mayFail = |x: Int| Err "something failed"
let result = 5 |> mayFail
result?

let addPair = |(x, y): (Int, Int)| x + y
-- Error: Type annotations on tuple patterns must be on individual elements
-- Hint: Use `|(x: Int, y: Int)|` instead of `|(x, y): (Int, Int)|`.

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

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

enum Person = { name: String, age: Int }
-- Error: Expected enum variant, found record syntax
-- Hint: Use an inline record type annotation instead.

let x = (1 + 2
-- Error: Unclosed '(' — expected ')'

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

let x = 1 + 2]
-- Error: Unexpected ']' — no matching '['

enum Result a e = Ok a | Err e
-- Result OkType ErrType: first parameter is success, second is error
-- Error: Enum variant 'Ok' appears to have data without parentheses
-- Hint: Use `Ok(a)` instead of `Ok a`. Variant data requires parentheses.

module CustomMath exposing ..

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

module CustomMath exposing ..

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

import List

-- filter: keep matching elements
[1, 2, 3, 4] |> List.filter (|x| x > 2)

import List

-- fold: reduce to single value
[1, 2, 3, 4] |> List.foldl (|acc x| acc + x) 0

import List

-- map: transform each element
[1, 2, 3] |> List.map (|x| x * 2)

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

fn addOne : Int -> Int
fn addOne x =

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

let add5 = add 5

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

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

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

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

module CustomMath exposing factorial

    fn factorial : Int -> Int
    fn factorial n =
        if n <= 1 then
            1

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

module CustomMath exposing fibonacci

    fn fibonacci : Int -> Int
    fn fibonacci n =
        if n <= 1 then
            n

import List

let doubled = List.map (|x| x * 2) [1, 2, 3]

let result =
    [1, 2, 3, 4, 5]

fn compose : (b -> c) -> (a -> b) -> a -> c
fn compose g f x =
    g (f x)

let double = |x : Int| x * 2

fn identity : a -> a
fn identity x =
    x

identity 42

-- 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

let withAlias = |x : Int as m| (x, m)

withAlias 42

let addOne = |x : Int| x + 1

let addTwo = |x : Int y : Int| x + y

let addTuple = |(x : Int, y : Int)| x + y

-- When the body constrains the parameter type, the annotation is optional.
-- Here x must be Int because x + 1 requires Int.
let f = |x| x + 1

f 1

import List

[1, 2, 3] |> List.map (|x| x * 2)

let compute =
    |x : Int|
        let y = 3
        x + y

compute 7

|x| x

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

describe { name = "Alice", age = 30 }

let getName = |{ name: String, .. }| name

getName { name = "Alice", age = 30 }

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

addPair (3, 4)

let f1 = |x : Int| x + 1

let f2 = |x : Int y : Int| x + y

let f3 = |(x : Int, y : Int)| x + y

let f = |x : Int| x + 1

f 1

import Math

fn quadraticFormula : Float -> Float -> Float -> (Float, Float)
fn quadraticFormula a b c =
    let discriminant = b * b - 4.0 * a * c
    let sqrtDisc =

fn makeAdder : Int -> (Int -> Int)
fn makeAdder n =
    |x : Int| x + n

makeAdder 10 5

import List
import Math
import String

let a =
    "hello"

module Apply exposing ..

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

module CustomMath exposing ..

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

module CustomMath 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 length : [a] -> Int
fn length list =
    case list of
        [] -> 0
        x :: xs -> 1 + length xs

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

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

-- Mixed typed and untyped fields (untyped inferred from context)
{ x = 1, y = 2 } |> |{ x: Int, y }| x + y

import List

-- Type inference flows through chained operations
-- Each lambda's parameter type is inferred from the previous result
[1, 2, 3, 4, 5]
    |> List.filter (|x| x > 2)

import List

-- Lambda parameter type inferred from List.filter signature
List.filter (|x| x > 2) [1, 2, 3, 4, 5]

-- [3, 4, 5]

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) 0 [1, 2, 3, 4]

import List

-- Lambda parameter type inferred from List.map signature
List.map (|x| x * 2) [1, 2, 3]

-- [2, 4, 6]

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) [1, 2, 3] [4, 5, 6]

fn fst : (Int, String) -> Int
fn fst pair =
    case pair of
        (x, _) -> x

fst (42, "hello")

fn swap : (a, b) -> (b, a)
fn swap pair =
    case pair of
        (x, y) -> (y, x)

swap (1, "hello")

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

add 3 4  -- 7

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

greet "World"

"Hello, World!"

-- 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"

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

let result =
    case value of
        1 ->

-- Multiline arguments work with COLLECTIONS (lists, records, tuples)

-- NOT with simple values like integers

import List

-- If-then-else with multiline expressions
let condition = True

let result =
    if condition then
        1 + 2

-- 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, 3, 4, 5]

List.sum numbers

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

let result = add 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, 2, 3]

import List

List.map (|x| x * 2) [1, 2, 3]

-- Pipes work naturally with multiline formatting
import List

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

-- 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
    let c = a + b

fn example : Int -> Int
fn example n =
    let a = n + 1
    let b = a * 2
    let c = a + b
    c

-- Lines at the SAME indentation are separate expressions
let x = 1

let y = 2

let z = 3

-- Type-safe column operations validated at compile time
import DataFrame
import DataFrame.Expr exposing col
import DataFrame.Expr as Expr
import Result

-- Built-in audit trails for regulatory compliance
import DataFrame
import Result

let payments =
    case DataFrame.readParquet "public/data/payments.parquet" of

-- Data contracts: schema enforced by the compiler, not documentation
import DataFrame

-- Read and validate DataFrame schema at compile time
let customers =
    case DataFrame.readParquet "public/data/customers.parquet" of

-- Automatic data lineage tracking
import DataFrame
import DataFrame.Expr exposing col
import DataFrame.Expr as Expr
import Result

True

'a'

42d  -- Integer decimal

3.14d  -- Fractional decimal

3.14

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

example 1

42  -- Decimal

-- This is a line comment
let x = 42  -- Inline comment

x

{ name = "Alice", age = 30 }

"Hello, World!"

()

-- Matrix multiplication and element-wise operators
import Matrix

let a = Matrix.fromRows [[1.0, 2.0], [3.0, 4.0]]
let b = Matrix.fromRows [[5.0, 6.0], [7.0, 8.0]]

-- Matrix basics: creation, shape, and element access
import Matrix

let m = Matrix.fromRows [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]
Matrix.shape m

-- Integer matrices for exact arithmetic
import Matrix

let m = Matrix.fromRowsInt [[1, 2], [3, 4]]
Matrix.toRows m

-- Solve a linear system Ax = b using LU decomposition
import Matrix

-- Solve: 2x = 6, 4y = 8
let a = Matrix.fromRows [[2.0, 0.0], [0.0, 4.0]]
let b = Matrix.fromList [6.0, 8.0]

-- SVD decomposition: singular values of a 2x2 matrix
import Matrix
import List

let m = Matrix.fromRows [[4.0, 3.0], [6.0, 3.0]]
let (u, s, vt) = Matrix.svd m

module CustomMath exposing add, multiply

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

module CustomMath exposing multiply

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

-- norun
-- Expose specific items
module exposing functionA, functionB, TypeA

-- Expose all
module exposing ..

module CustomMath exposing fibonacci

    fn fibonacci : Int -> Int
    fn fibonacci n =
        if n <= 1 then
            n

module exposing createUser, getName

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

fn getName : { name: String, age: Int } -> String

import Math

module Geometry exposing Shape, area, perimeter

    enum Shape
        = Circle(Float)

module Geometry exposing perimeter

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

import List as L exposing length

length [1, 2]

import List as L
-- Modules and import aliases
import Math as M

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]

import List exposing map, filter

map (|x : Int| x + 1) [1, 2, 3]

module CustomMath exposing add

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

-- Error: Inline module content must be indented
module CustomMath exposing add

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

module CustomMath exposing add, multiply

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

-- norun

module exposing double, square

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

module CustomMath exposing factorial, fibonacci

    fn factorial : Int -> Int
    fn factorial n =
        if n <= 1 then
            1

module Math exposing double

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

module Shapes exposing Shape, area

    enum Shape
        = Circle(Float)
        | Square(Float)

import Json
import List
import Maybe
import Result
import String

-- norun

module exposing greeting

import String

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 : [Int] = 1 :: (2 :: [])

-- Concatenation

-- 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, 4, 5]
    |> List.filter (|x| x > 2)
    |> List.map (|x| x * 2)

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

result  -- False

"Hello, " ++ "World!"

-- ? unwraps Ok values and short-circuits on Err
let addOne = |x: Int| Ok (x + 1)
let result = 5 |> addOne
result?

let x = 1 + 2.5

let y = 3 * 1.5

x + y

let maybe = Just 42

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

let list = [1, 2, 3]

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

case 1 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"

enum 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 (1, 2) (3, 4)  -- (4, 6)

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"
    [x, y] -> "pair"

let x = 1

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

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

case list of
    a :: b :: rest -> a + b
    x :: xs -> x
    [] -> 0

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

enum Direction
    = North
    | South
    | East
    | West

enum Color = Red | Green | Blue

let color = Color::Green

case color of
    Color::Red -> "fire"

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

case person of
    { name, age } -> name

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

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