func main() {
    IO.puts("Hello, world!")
}

CopyHello, world!

func main() {
    let x = 5
    let name: String = "Alice"   // explicit annotation is optional
    IO.puts(name)
    IO.puts(String(x))
}

CopyAlice
5

func main() {
    let [first, second] = [1, 2, 3]
    IO.inspect(first)                    // 1

    let [head, ...tail] = [1, 2, 3]
    IO.inspect(head)                     // 1
    IO.inspect(tail)                     // [2, 3]

    let [...most, last] = [1, 2, 3]
    IO.inspect(most)                     // [1, 2]
    IO.inspect(last)                     // 3
}

Copy1
1
[2, 3]
[1, 2]
3

func main() {
    let [_, second, ...] = [10, 20, 30, 40]
    IO.inspect(second)                   // 20
}

Copy20

let greeting = "Hello from Oak"   // top-level let binding is allowed

func main() {
    IO.puts(greeting)
}

CopyHello from Oak

func greet(name: String) -> String {
    "Hello, \(name)!"
}

func main() {
    IO.puts(greet(name: "Alice"))
    IO.puts(greet(name: "Bob"))
}

CopyHello, Alice!
Hello, Bob!

func move(from source: String, to destination: String) -> String {
    "\(source) → \(destination)"
}

func double(_ x: Integer) -> Integer { x * 2 }

func main() {
    IO.puts(move(from: "A", to: "B"))   // call site uses external labels
    IO.puts(String(double(5)))           // no label required
}

CopyA → B
10

func factorial(_ n: Integer) -> Integer {
    func go(_ n: Integer, _ acc: Integer) -> Integer {
        if n <= 1 { acc } else { go(n - 1, n * acc) }
    }
    go(n, 1)
}

func main() {
    IO.puts(String(factorial(5)))
    IO.puts(String(factorial(10)))
}

Copy120
3628800

func isGt3(_ n: Integer) -> Bool { n > 3 }
func double(_ n: Integer) -> Integer { n * 2 }

func main() {
    let values = [3, 1, 4, 1, 5, 9]
    IO.inspect(Array.sorted(values))
    IO.inspect(Array.filter(values, isGt3))
    IO.inspect(Array.map(values, double))
}

Copy[1, 1, 3, 4, 5, 9]
[4, 5, 9]
[6, 2, 8, 2, 10, 18]

struct Person {
    name: String
    age: Integer
}

let people = [
    Person(name: "Alice", age: 30),
    Person(name: "Bob", age: 17),
    Person(name: "Carol", age: 25)
]

func isAdult(_ p: Person) -> Bool { p.age >= 18 }
func getName(_ p: Person) -> String { p.name }

func main() {
    let adults = Array.filter(people, isAdult)
    IO.inspect(Array.map(adults, getName))
}

Copy["Alice", "Carol"]

func main() {
    let name = "Alice"
    IO.puts("Hello, \(name)!")
    IO.puts("2 + 2 = \(2 + 2)")
}

CopyHello, Alice!
2 + 2 = 4

func main() {
    IO.inspect(Empty)               // constructor value
    IO.inspect(Value(42))           // constructor with one positional arg
    IO.inspect(Error(msg: "oops"))  // constructor with named arg
}

CopyEmpty
Value(42)
Error(msg: "oops")

type Direction = North | South | East | West

func describe(d: Direction) -> String {
    switch(d) {
        when North { "heading north" }
        when South { "heading south" }
        when East  { "heading east" }
        when West  { "heading west" }
    }
}

func main() {
    IO.puts(describe(d: North))
    IO.puts(describe(d: East))
}

Copyheading north
heading east

func main() {
    let names: Array<Element: String> = ["Alice", "Bob"]
    IO.inspect(Array.count(names))
}

Copy2

struct Point {
    x: Integer
    y: Integer
}

func main() {
    let p = Point(x: 3, y: 4)
    let q = Point(y: 4, x: 3)   // same value — label order doesn't matter
    IO.puts("x=\(p.x), y=\(p.y)")
}

Copyx=3, y=4

struct Point {
    x: Integer
    y: Integer
}

module Point {
    func Self(onYAxis y: Integer) -> Self { Point(x: 0, y: y) }
}

func main() {
    let p = Point.Self(onYAxis: 5)
    IO.puts("x=\(p.x), y=\(p.y)")
}

Copyx=0, y=5

struct Stats {
    count: Integer
    sum:   Integer
    min:   Integer
    max:   Integer
}

func myAdd(_ a: Integer, _ b: Integer) -> Integer { a + b }
func myMin(_ a: Integer, _ b: Integer) -> Integer { if a < b { a } else { b } }
func myMax(_ a: Integer, _ b: Integer) -> Integer { if a > b { a } else { b } }

type StatsError = ZeroCount

module Stats {
    func compute(from values: Array<Element: Integer>) throws StatsError -> Stats {
        if Array.count(values) == 0 { throw ZeroCount }
        Stats(
            count: Array.count(values),
            sum:   Array.reduce(values, initial: 0, fn: myAdd),
            min:   Array.reduce(values, initial: values[0], fn: myMin),
            max:   Array.reduce(values, initial: values[0], fn: myMax)
        )
    }
}

func main() {
    do {
        let s = try Stats.compute(from: [4, 1, 9, 2, 7])
        IO.puts("count=\(s.count), sum=\(s.sum), min=\(s.min), max=\(s.max)")
    } catch ZeroCount {
        IO.puts("empty input")
    }
}

Copycount=5, sum=23, min=1, max=9

module String {
    func shout(s: String) -> String { String.upcase(s) + "!" }
}

func main() {
    IO.puts(String.shout(s: "hello"))
    IO.puts(String.shout(s: "oak"))
}

CopyHELLO!
OAK!

func main() {
    let x = 5

    if x > 0 {
        IO.puts("positive")
    } else {
        IO.puts("non-positive")
    }

    let label = if x > 0 { "pos" } else { "non-pos" }
    IO.puts(label)
}

Copypositive
pos

func main() {
    for item in ["a", "b", "c"] {
        IO.puts(item)
    }
}

Copya
b
c

type Status = Ok | Warn | Error

func main() {
    let n = 7
    let label = switch n {
        when 1 { "one" }
        when 2 { "two" }
        else   { "other" }
    }
    IO.puts(label)
}

Copyother

func main() {
    let score = 75
    let grade = switch {
        when score >= 90 { "A" }
        when score >= 80 { "B" }
        when score >= 70 { "C" }
        else             { "F" }
    }
    IO.puts(grade)
}

CopyC

func parseLine(_ s: String) -> ParseResult {
    let trimmed = String.trim(s)
    if String.isEmpty(trimmed) {
        Empty
    } else {
        do {
            Value(n: Array.count(String.graphemes(trimmed)))
        } catch {
            Invalid(trimmed)
        }
    }
}

type ParseResult = Value(n: Integer) | Empty | Invalid(text: String)

func go(inputs: Array<Element: String>, acc: Array<Element: Integer>) -> Array<Element: Integer> {
    if Array.isEmpty(inputs) {
        acc
    } else {
        let input  = inputs[0]
        let rest   = Array.slice(inputs, from: 1, to: Array.count(inputs))
        let result = parseLine(input)
        switch result {
            when Value   { go(inputs: rest, acc: acc + [result.n]) }
            when Empty   { go(inputs: rest, acc: acc) }
            when Invalid {
                IO.puts("'\(result.text)' is not a number")
                go(inputs: rest, acc: acc)
            }
        }
    }
}

func main() {
    let results = go(inputs: ["3", "", "hello", "5"], acc: [])
    IO.inspect(results)
}

Copy[1, 5, 1]

type ParseResult = Value(n: Integer) | Empty | Invalid(text: String)
func parseLine(_ s: String) -> ParseResult { Value(n: 0) }
func go(inputs: Array<Element: String>, acc: Array<Element: Integer>) -> Array<Element: Integer> { acc }

func main() {
    let r = parseLine("42")
    switch r {
        when Value   { IO.inspect(r.n) }
        when Empty   { IO.puts("empty") }
        when Invalid { IO.puts("invalid: \(r.text)") }
    }
}

Copy0

type Status = Ok | Error

func main() {
    let status = Ok
    let label = switch(status) {
        when Ok    { "good" }
        when Error { "bad" }
    }
    IO.puts(label)
}

Copygood

func myAdd(_ a: Integer, _ b: Integer) -> Integer { a + b }

type StatsError = ZeroCount

// Explicit thrown type annotation
func computeSum(from values: Array<Element: Integer>) throws StatsError -> Integer {
    if Array.count(values) == 0 { throw ZeroCount }
    Array.reduce(values, initial: 0, fn: myAdd)
}

func main() {
    do {
        let total = try computeSum(from: [1, 2, 3, 4, 5])
        IO.puts("sum = \(total)")
    } catch ZeroCount {
        IO.puts("No numbers provided.")
    }
}

Copysum = 15

func myAdd(_ a: Integer, _ b: Integer) -> Integer { a + b }
type StatsError = ZeroCount

func computeSum(from values: Array<Element: Integer>) throws StatsError -> Integer {
    if Array.count(values) == 0 { throw ZeroCount }
    Array.reduce(values, initial: 0, fn: myAdd)
}

func main() {
    do {
        let total = try computeSum(from: [1, 2, 3])
        IO.puts("sum = \(total)")
    } catch ZeroCount {
        IO.puts("No numbers provided.")
    }
}

Copysum = 6

type StatsError = ZeroCount

func myAdd(_ a: Integer, _ b: Integer) -> Integer { a + b }

func computeSum(from values: Array<Element: Integer>) throws StatsError -> Integer {
    if Array.count(values) == 0 { throw ZeroCount }
    Array.reduce(values, initial: 0, fn: myAdd)
}

func printSum(_ n: Integer) { IO.puts("sum = \(n)") }

func main() {
    do {
        let total = try computeSum(from: [10, 20, 30])
        printSum(total)   // propagate throw to caller
    } catch ZeroCount {
        IO.puts("empty")
    }
}

Copysum = 60

type StatsError = ZeroCount

func myAdd(_ a: Integer, _ b: Integer) -> Integer { a + b }

func computeSum(from values: Array<Element: Integer>) throws StatsError -> Integer {
    if Array.count(values) == 0 { throw ZeroCount }
    Array.reduce(values, initial: 0, fn: myAdd)
}

func main() {
    let total = try? computeSum(from: [1, 2, 3])
    IO.puts(total ?? "no result")

    let nothing = try? computeSum(from: [])
    IO.puts(nothing ?? "no result")
}

Copy6
no result

type StatsError = ZeroCount

func myAdd(_ a: Integer, _ b: Integer) -> Integer { a + b }

func computeSum(from values: Array<Element: Integer>) throws StatsError -> Integer {
    if Array.count(values) == 0 { throw ZeroCount }
    Array.reduce(values, initial: 0, fn: myAdd)
}

func main() {
    let total = try! computeSum(from: [1, 2, 3])
    IO.puts("sum = \(total)")
}

Copysum = 6

type StatsError = ZeroCount

func myAdd(_ a: Integer, _ b: Integer) -> Integer { a + b }

func computeSum(from values: Array<Element: Integer>) throws StatsError -> Integer {
    if Array.count(values) == 0 { throw ZeroCount }
    Array.reduce(values, initial: 0, fn: myAdd)
}

func main() {
    do {
        let total = try computeSum(from: [])
        IO.puts("sum = \(total)")
    } catch ZeroCount {
        IO.puts("No numbers entered.")
    } catch {
        IO.puts("Unknown error.")
    }
}

CopyNo numbers entered.

type ParseResult = Value(Integer) | Invalid(String)

func main() {
    let line = "  42  "
    let result = do {
        Value(Array.count(String.graphemes(String.trim(line))))
    } catch {
        Invalid(line)
    }
    IO.inspect(result)
}

CopyValue(2)

func main() {
    IO.puts("hello, world")
    IO.puts("line one\nline two")
    IO.puts("tab\there")
    let name = "Alice"
    IO.puts("Hello, \(name)!")
}

Copyhello, world
line one
line two
tab	here
Hello, Alice!

func main() {
    IO.inspect(String.graphemes("café"))
    IO.inspect(Array.count(String.graphemes("café")))
}

Copy["c", "a", "f", "é"]
4

func main() {
    let nums  = [1, 2, 3]
    let names = ["Alice", "Bob"]

    IO.inspect(nums[0])
    IO.inspect([1, 2] + [3, 4])
    IO.inspect(names)
}

Copy1
[1, 2, 3, 4]
["Alice", "Bob"]

func main() {
    let a = [1, 2, 3]
    IO.inspect([0, ...a, 4])          // [0, 1, 2, 3, 4]

    let defaults = { "timeout": 30, "retries": 3 }
    let config = { ...defaults, "timeout": 60 }
    IO.inspect(config)                // {"timeout": 60, "retries": 3}
}

Copy[0, 1, 2, 3, 4]
{"timeout": 60, "retries": 3}

func main() {
    let scores = { "Alice": 10, "Bob": 7 }
    IO.inspect(scores["Alice"])
    IO.inspect(Dict.keys(scores))
}

Copy10
["Alice", "Bob"]

func main() {
    "hello world!" |> IO.puts()

    let result = [3, 1, 2]
        |> Array.sorted()
        |> Array.reversed()
    IO.inspect(result)
}

Copyhello world!
[3, 2, 1]

func main() {
    let result = 10 |> Math.pow(2, _)   // Math.pow(2, 10)
    IO.inspect(result)
}

Copy1024

func main() {
    IO.inspect(5 |> _ + _)   // 10
}

Copy10

func main() {
    let str = "hello"
    str |> String.repeat(count: 3) |> IO.puts()
}

Copyhellohellohello

func main() {
    let result = 10 |> Math.pow(2, _)
    IO.inspect(result)   // Math.pow(2, 10) = 1024
}

Copy1024

func main() {
    let doubled = 5 |> _ + _
    IO.inspect(doubled)   // 5 + 5 = 10
}

Copy10

func main() {
    "hello" |> IO.puts()
    let sorted = [3,1,2] |> Array.sorted()
    IO.inspect(sorted)
}

Copyhello
[1, 2, 3]

func main() {
    IO.inspect(Math.add(a: 3, b: 4))   // ✓  named function call
    IO.inspect(Math.min(a: 9, b: 2))
    IO.inspect(Math.abs(-7))
}

Copy7
2
7

let a: Int8 = 120i8
let b: Int8 = 10i8

func main() {
    let a = 120i8
    let b = 10i8
    IO.inspect(a &+ b)   // wraps instead of trapping
}

Copy-126

func main() {
    let n = 5
    IO.inspect(1 <= n && n <= 10)
}

CopyTrue

func main() {
    let scores = { "Alice": 10, "Bob": 7 }
    let value = Dict.get(scores, key: "Carol") ?? 0
    IO.inspect(value)
}

Copy0

func main() {
    IO.inspect(2 ** 64)
    IO.inspect(2 ** 128)
}

Copy18446744073709551616
340282366920938463463374607431768211456

func main() {
    let a = 1 / 3
    let b = 2 / 3
    IO.inspect(a + b)   // exactly 1, not 0.9999...
    IO.inspect(a * 6)   // exactly 2
}

Copy1
2

func main() {
    IO.inspect(42)      // Integer
    IO.inspect(3.14)    // Rational
    IO.inspect(1 / 3)   // Rational — expression, not a special literal
}

Copy42
3.14
0.3333333333

func main() {
    IO.inspect(0xFF)
    IO.inspect(0b1010)
    IO.inspect(0o17)
}

Copy255
10
15

func main() {
    IO.inspect(1_000_000)
    IO.inspect(0xFF_EC_00_1A)
}

Copy1000000
4293656602

func main() {
    IO.inspect(3.5e2)    // → 350     (Integer)
    IO.inspect(1.5e-1)   // → 0.15   (Rational)
    IO.inspect(1e10)     // → 10000000000
}

Copy350
0.15
10000000000

func main() {
    IO.inspect(255u8)
    IO.inspect(1000i32)
    IO.inspect(3.14f64)
}

Copy255
1000
3.14

import { Vector } from "./geometry"          // selective — brings Vector into scope
import { Foo: Bar } from "./utils"           // rename — Foo enters scope as Bar
import * from "./utils"                      // wildcard — all public declarations
import Utils from "./utils"                  // namespace — all public declarations under Utils.X

import { encode, decode: parse } from "json"

import { Vector } from "./geometry/vector"
import { Config } from "../config"

import { encode, decode } from "json"
import * from "http"
import Math from "math"

import * from git(repo: "[email protected]:example/oak-extras.git", hash: "a3f8c2e9...")

import Math from "math"

func main() {
    IO.puts(String(Math.sqrt(144)))
    IO.puts(String(Math.pow(base: 2, exp: 10)))
}

Copy12
1024

func main() {
    let str = "hello"
    String.puts(str)
    str |> String.upcase() |> IO.puts()
}

Copyhello
HELLO

func main() {
    IO.inspect([1, 2] + [3, 4])
}

Copy[1, 2, 3, 4]

func main() {
    let scores = { "Alice": 10, "Bob": 7 }
    IO.inspect(scores["Alice"])
    IO.inspect(Dict.count(scores))
}

Copy10
2

func main() {
    IO.inspect(Math.add(a: 3, b: 4))
    IO.inspect(Math.min(a: 9, b: 2))
    IO.inspect(Math.max(a: 9, b: 2))
    IO.inspect(Math.abs(-7))
    IO.inspect(Math.sqrt(16))
}

Copy7
2
9
7
4

func main() {
    let a = 3 / 2    // rational division
    let b = 1 / 2
    IO.inspect(a + b)
    IO.inspect(a * b)
    IO.inspect(a > b)
}

Copy2
0.75
True

func main() {
    let p = spawn {
        IO.sleep(ms: 10)
        "done"
    }
    let result = await p
    IO.puts(result)
}

Copydone

func doWork() -> String { "work complete" }

func main() {
    let p = spawn(label: "worker") {
        doWork()
    }
    IO.puts(await p)
}

Copywork complete

func main() {
    let p = spawn { "hello from fiber" }
    let result = await p
    IO.puts(result)
}

Copyhello from fiber

func main() {
    let p1 = spawn { IO.sleep(ms: 10)  "first" }
    let p2 = spawn { IO.sleep(ms: 5)   "second" }
    let [r1, r2] = await [p1, p2]
    IO.puts(r1)
    IO.puts(r2)
}

Copyfirst
second

type WorkError = Failed
func riskyWork() throws WorkError -> String {
    throw Failed
}

func main() {
    let p = spawn { try riskyWork() }

    do {
        let result = await p
        IO.puts(result)
    } catch Failed {
        IO.puts("caught")
    }
}

Copycaught

type TelemetryError = Timeout
func telemetry() throws TelemetryError { throw Timeout }

func main() {
    let p = spawn {
        do { try telemetry() } catch { }   // discard errors
        "done"
    }
    await p
    IO.puts("finished")
}

Copyfinished

func main() {
    let p1 = spawn {
        IO.sleep(ms: 50)
        "result1"
    }
    let p2 = spawn {
        IO.sleep(ms: 100)
        "result2"
    }
    let [r1, r2] = await [p1, p2]
    IO.puts(r1)
    IO.puts(r2)
}

Copyresult1
result2

func main() {
    let ch = Channel.new()

    let sender = spawn {
        ch.send(1)
        ch.send(2)
        ch.send(3)
    }

    IO.puts(ch.receive())
    IO.puts(ch.receive())
    IO.puts(ch.receive())
    await sender
}

Copy1