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: List Int = [4, 5, 6]
ys

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

let list2 =

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)

-- Fold: reduce to single value
import List

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

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 users =
    [ { name = "Alice", age = 30 }
    , { name = "Bob", age = 25 }
    , { name = "Charlie", age = 35 }
    ]
users

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

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

-- Record update syntax

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

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

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

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 = Color::Green

case color of
    Color::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 = 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"

let maybeUser = Just "Alice"

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

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

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

type 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
type Result a e = Ok(a) | Err(e)

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

DataFrame.fromRecords
    [ { group = "A", value = 10 }

-- Arithmetic expressions: column * column
import DataFrame
import DataFrame.Expr as Expr

DataFrame.fromRecords
    [ { price = 10, quantity = 3 }

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

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

-- Comparison expressions: column >= literal
import DataFrame
import DataFrame.Expr as Expr

DataFrame.fromRecords
    [ { name = "Alice", age = 25 }

-- Conditional expressions with DataFrame.Expr
import DataFrame
import DataFrame.Expr exposing (col, lit)
import DataFrame.Expr as Expr

DataFrame.fromRecords

-- Math functions: abs
import DataFrame
import DataFrame.Expr as Expr

DataFrame.fromRecords
    [ { value = -3.7 }

-- Null handling: fillNull
import DataFrame
import DataFrame.Expr as Expr

DataFrame.fromRecords
    [ { score = 85 }

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

DataFrame.fromRecords
    [ { name = "alice" }

import DataFrame
import DataFrame.Expr as Expr

let df = DataFrame.fromRecords
    [ { region = "East", revenue = 100 }
    , { region = "East", revenue = 200 }

-- norun
-- Aggregated columns track source and function
import DataFrame

let df =
    DataFrame.fromRecords

-- norun
-- Lineage appears automatically when printing a DataFrame
import DataFrame

let sales =
    DataFrame.fromRecords

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

let df =
    DataFrame.fromRecords

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

let users =
    DataFrame.fromRecords

-- norun
-- Full lineage record structure
import DataFrame

let df =
    DataFrame.fromRecords

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

let df =
    DataFrame.fromRecords

-- Root DataFrames have no parents
import DataFrame

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

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

let df =
    DataFrame.fromRecords

-- DataFrame.sourcePath returns Nothing for fromRecords
import DataFrame

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

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

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

let df =
    DataFrame.fromRecords

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

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"

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

import List

List.map 42 [1, 2, 3]
-- Error: Type mismatch: expected (a -> b), found Int
-- Hint: Function signature: (a -> b) -> [a] -> [b]
--       Expected argument type: (a -> b), but got: Int

import String

String.length 42
-- Error: Type mismatch: expected String, found Int
-- Hint: Function signature: String -> Int
--       Expected argument type: String, but got: Int

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

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

Err "x" |> Result.toMaybe

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 value = Just 5

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

import IO exposing (print)

let userName = "Alice"
let userAge = 30
let userEmail = "alice@example.com"

import IO exposing (print)
let userName = "Alice"
let userAge = 30
print usrName
-- Error: Variable 'usrName' not found. Did you mean 'userName' or 'userAge'?

import Json

let data = Json.parse "{\"x\": 1}"
-- Error: Generic function result requires a type annotation for variable 'data'
-- Hint: Add a type annotation to specify the expected type

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

Nothing |> Maybe.withDefault 0

import Maybe

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

-- Chain operations that might return Nothing

-- Safe error handling with Maybe
import List
import Maybe

-- Extract values with default fallback
[Just 42, Nothing, Just 7]

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

Err "bad" |> Result.mapError (|e| "Error: " ++ e)

import Result

-- Transform success values
let mapped = 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

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

type Person = { name: String, age: Int }
-- Error: Expected enum variant, found record syntax
-- Hint: Use 'type alias' to define a record type alias.

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

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

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

type 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 = x + 1

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

let add5 = add 5
add5 3

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 else n * factorial (n - 1)

CustomMath.factorial 5

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 else fibonacci (n - 1) + fibonacci (n - 2)

CustomMath.fibonacci 10

import List

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

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

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

let double = |x: Int| x * 2
let addOne = |x: Int| x + 1

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 as m: Int| (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

addOne 5

|x| x + 1

import List

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

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

compute 7

|x| x + 1

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 f4 = |f: Int -> Int| f 1

f4 (|x: Int| x * 2)

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 = Math.sqrt discriminant

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

makeAdder 10 5

import String

"hello" |> String.toUpper |> String.length

import String
import List
import Math

let a = "hello" |> String.toUpper |> String.length
let b = "hello" |> String.slice 0 3 |> String.toUpper

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]

let pair = (42, "hello")
let (x, _) = pair
x

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

fst (42, "hello")

let pair = (1, "hello")
let (x, y) = pair
(y, x)

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

let x =
    1 + 2 + 3
x

let greeting =
    "hello"
greeting

let a =
    5
let b =
    10
a + b

let result =
1 + 2 + 3

let x =
    let y = 3
    let z = 4
    y + z
x

let greeting =
"hello"

let x =
x + 1

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

let x =

let a = 10
let b =

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

let numbers =
    [ 1
    , 2

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

let result = add 1 2
result

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

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

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

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

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

let sales = DataFrame.readParquet "public/data/sales.parquet"

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

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

let auditReport = payments

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

type alias Schema =
    { customer_id: Int
    , name: String

-- Automatic data lineage tracking
import DataFrame
import DataFrame.Expr as Expr

let transactions = DataFrame.readParquet "public/data/transactions.parquet"

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

()

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

import Math

module Geometry exposing (Shape, area, perimeter)

    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

import List as L exposing (length)
length [1, 2]

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

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

module CustomMath exposing (factorial, fibonacci)

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

module Math exposing (double)
    fn double : Int -> Int
    fn double x = x * 2

Math.double 5

module Shapes exposing (Shape, area)
    type Shape = Circle(Float) | Square(Float)

    fn area : Shape -> Float
    fn area shape = case shape of
        Circle r -> 3.14 * r * r

import List
import String
import Result
import Maybe
import Json

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

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"

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

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

type Direction
    = North
    | South
    | East
    | West

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

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

"Hello from my-project!"

-- my-pipeline data pipeline
-- Run with: keel run

let { data } = Task.run "steps/extract.kl" ()
let { transformed } = Task.run "steps/transform.kl" (data)
Task.run "steps/load.kl" (transformed)

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

True + 1

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

let numbers: [Int] = [1, 2, 3]
let names: [String] = ["Alice", "Bob"]
let nested: [[Int]] = [[1, 2], [3, 4]]
nested

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

let price = 19.99d
let tax = 0.07d
let total = price + price * tax

total

type Pair a b = Pair(a, b)

let p = Pair::Pair(1, "hello")
p

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

let tree: Tree Int = Tree::Node(Tree::Leaf(1), 2, Tree::Node(Tree::Leaf(3), 4, Tree::Leaf(5)))

-- Higher-order function context
import List 

-- Higher-order function context
[1, 2, 3] |> List.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

import List 

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

import Json

let data: Result { name: String } String = Json.parse "{\"name\": \"Alice\"}"
data

|x| x + 1

|x: Int| x + 1

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

-- norun
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 Person = { name: String, age: Int }
type alias MinPerson = { name: String, age: Int, .. }

let p: MinPerson = { name = "Alice", age = 30, email = "a@b.com" }
p.name

import DataFrame

-- Open record type allows extra fields
type alias MinSchema = { name: String, age: Int, .. }
let data: DataFrame MinSchema = DataFrame.fromRecords [{ name = "Alice", age = 30, email = "alice@example.com" }]
DataFrame.columns data

type alias Container a = { value: a }

let intBox =
    { value = 42 }

intBox.value

let x: Result (Maybe Int) String = Ok (Just 5)
let y: Maybe (List Int) = Just [1, 2, 3]
let z: List (Maybe Int) = [Just 1, Nothing, Just 2]
z

let x: Result (Maybe Int) String = Ok (Just 5)
x

-- 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 = MyList::Cons(1, MyList::Cons(2, MyList::Cons(3, MyList::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

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

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

Shape::Rectangle(10.0, 20.0)

type Direction = North | South | East | West

let heading = Direction::North
heading

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

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

y