Syntax Reference

# Comments begin with # and run to end of line
# Multi-line comments don't exist. Just keep adding new comment lines.

a = 1
b = 3.14

# Numbers are 64-bit values. The binary representation is u64, i64, or f64
# depending on the needs of the program. Negation or division converts as needed.
half = 10 / 3    # auto-converts to float

str = "This is a string"

# Escape sequences
str = "Line 1\nLine 2"

# String interpolation: expressions inside {} are evaluated
name = "World"
greeting = "Hello {name}!"        # "Hello World!"
result = "Sum: {1 + 2}"           # "Sum: 3"
obj = [key: "value"]
nested = "Key: {obj[:key]}"       # expressions can be complex

# Escape literal braces with {{ and }}
literal = "Use {{braces}}"        # "Use {braces}"

# Concatenation with +
"hello" + " " + "world"           # "hello world"

flag = true
done = false
type(true)    # :boolean

:active
:csv
:also_a_symbol

type(:active)    # :symbol

# There is no null keyword. Null arises from:
# - Accessing a missing container index: [][0]
# - A function with no explicit return value
# - An if expression with no else branch when the condition is false

missing = [][0]
type(missing)     # :null

# Null is falsy
if missing { "truthy" } else { "falsy" }    # "falsy"

x = 42
name = "Weave"

# Augmented assignment
x += 10    # x = x + 10
x -= 3     # x = x - 3
x *= 2     # x = x * 2
x /= 4    # x = x / 4
x %= 5     # x = x % 5

# Works on container elements too
c = [a: 10]
c[:a] += 5    # c[:a] is now 15

# puts() prints with trailing newline
puts("Hello, World!")
puts(42)
puts([1, 2, 3])

# print() prints without trailing newline
print("Loading...")

x = 5
flag = true
count = 15
fn process(items) { items }
items = ["a", "b", "c"]

result = if x > 0 { "positive" } else { "non-positive" }

# Without else, returns null when condition is false
maybe = if flag { "yes" }

# Multi-line
if count > 10 {
    puts("Many items")
    process(items)
} else {
    puts("Few items")
}

i = 0
while i < 10 {
    puts(i)
    i += 1
}

# while is a statement (evaluates to null)
# Note: there are no break or continue keywords

# Define with fn keyword
fn add(a, b) {
    a + b    # last expression is implicitly returned
}

# Default parameters (required params must come first)
fn greet(name, greeting: "Hello") {
    greeting + " " + name
}

puts(greet("World"))           # "Hello World"
puts(greet("World", "Hi"))     # "Hi World"

# Named arguments use the same key: value syntax as containers
fn div(a, b) { a / b }
div(b: 3, a: 2)    # 0.6666...

# return exits a function early with a value
fn find_first(items, target) {
    i = 0
    while i < items.len {
        if items[i] == target { return i }
        i += 1
    }
    return -1
}

# Bare return (no value) produces null and is discouraged.
# Prefer structuring code to avoid it:
fn maybe_process(flag) {
    if flag { do_work() }
}

double = ^(x) { x * 2 }
double(5)    # 10

# Multi-line
process = ^(x) {
    x = x + 1
    x * 2
}

# Inline with pipeline operators
[1, 2, 3] *> ^(x) { x * 2 }    # [2, 4, 6]

# Lambdas are scoped to their declaring block
fn outer(a, b) {
    add = ^(a, b) { a + b }
    add(a + 1, b + 1)
}
# add is not accessible here

fn add(a, b) { a + b }

# *args collects remaining arguments into a container
fn partial(func, arg1) {
    ^(*args) { func(arg1, *args) }
}

add_5 = partial(add, 5)
add_5(10)    # 15

fn make_adder(n) {
    a = 1
    ^(x) { x + n + a }    # captures n and a
}

add_6 = make_adder(5)
add_6(10)    # 16

# List-style
l = [1, 2, 3]

# Map-style with key: value pairs
m = [a: 1, b: 3, c: 5]

# Mixed
data = [1, :a, [27, "nested"]]

# Access by index or key
m[0]      # 1
m[:b]     # 3
l[-1]     # 3 (negative index from end)

# Assignment
m[:a] = 3
l << "new item"    # append

m = [a: 1, b: 2]
m.keys       # [:a, :b]
m.len        # 2
"hello".len  # 5

list = [10, 20, 30, 40, 50]
list[1:3]    # [20, 30]

str = "Hello"
str[0:3]     # "Hel"

a = [1, 2, 3]
b = [2, 3, 4]

a + b     # [1, 2, 3, 2, 3, 4]
a | b     # [1, 2, 3, 4]
a & b     # [2, 3]
a !& b    # [1, 4]
a - b     # [1]

sum = ^(x, acc: 0) { acc + x }
[a: 1, b: 2, 3, 4] &> sum    # 10 (never sees :a or :b)

# Modules are plain .wv files
# Path maps to file: import foo.bar -> ./foo/bar.wv

# Import the module namespace
import foo.bar
value = foo.bar[:x]

# Import with alias
import foo.bar as fb

# Import specific symbols
from foo.bar import x
from foo.bar import add as sum

# Import multiple symbols
from foo.bar import x, y, z

# Wildcard import
from foo.bar import *

filename = "missing.txt"

result = handle {
    file_not_found: ^(source, c) { c.resume(:skip) }
} for {
    report(:file_not_found, path: filename) {
        abort: ^() { exit(1) },
        skip: ^() { [] },
        create: ^() { write(filename, ""); "" }
    }
}

filename = "config.toml"
fn load_config() { read(filename) }

result = handle {
    file_not_found: ^(source, c) {
        puts("Missing file in {source}, creating...")
        c.resume(:use_value, [host: "localhost"])
    }
} for {
    load_config()
}

fn risky_operation() {
    report(:known_error) { fix: ^() { "recovered" } }
}

handle {
    known_error: ^(source, c) { c.resume(:fix) },
    _: ^(source, c) {
        puts("Unexpected: {c.type}")
        c.resume(:abort)
    }
} for {
    risky_operation()
}

# Empty strategy block creates a notification (continues silently if unhandled)
x = 42
report(:debug_info, value: x) {}