Functions and closures

Functions are first-class values. XS supports default parameters, variadic args, closures, generators, and overloading by argument count.

Basics

scratch.xs

-- basic declaration
fn greet(name) {
  println("Hello, {name}!")
}
greet("world")

-- expression body shorthand
fn double(x) = x * 2
println(double(5))

-- implicit return (last expression)
fn square(x) { x * x }
println(square(4))

-- with type annotations
fn add(a: int, b: int) -> int {
  return a + b
}
println(add(3, 4))

fn main() is auto-called if defined. In scripts without a main, the top-level code runs directly.

Default args and variadic

scratch.xs

fn greet(name, greeting = "hello") {
  return "{greeting}, {name}"
}
println(greet("world"))          -- hello, world
println(greet("world", "hi"))    -- hi, world

scratch.xs

fn sum(...args) {
  var total = 0
  for a in args { total += a }
  return total
}
println(sum(1, 2, 3))            -- 6
println(sum())                   -- 0

Closures

Closures capture variables by reference through an environment chain. Mutations inside the closure are visible to the outer scope.

scratch.xs

fn make_counter() {
  var count = 0
  return fn() {
    count += 1
    return count
  }
}

let c = make_counter()
println(c())                     -- 1
println(c())                     -- 2
println(c())                     -- 3

scratch.xs

-- arrow lambda syntax
let inc = (x) => x + 1
let mul = (a, b) => a * b

println(inc(5))                  -- 6
println(mul(3, 4))               -- 12

Generators

Generator functions use fn* and yield to produce values lazily. They work with for..in loops.

scratch.xs

fn* count_up(n) {
  var i = 0
  while i < n {
    yield i
    i += 1
  }
}

for x in count_up(5) {
  print("{x} ")
}
println()                        -- 0 1 2 3 4

Overloading

Multiple functions with the same name are dispatched by argument count. First exact arity match wins.

scratch.xs

fn area(r) = 3.14159 * r * r
fn area(w, h) = w * h

println(area(5))                 -- 78.53975
println(area(3, 4))              -- 12

Functions defined later in a file can call functions defined earlier, and also vice versa (mutual recursion is fine):

scratch.xs

fn is_even(n) {
  if n == 0 { return true }
  return is_odd(n - 1)
}
fn is_odd(n) {
  if n == 0 { return false }
  return is_even(n - 1)
}
println(is_even(10))             -- true
println(is_odd(7))               -- true

Function attributes

-- @test: marks the function as a test case (run by xs test)
@test
fn test_add() {
  assert_eq(1 + 2, 3)
}

-- @deprecated: warns callers at check time
@deprecated("use new_add() instead")
fn old_add(a, b) { return a + b }

Test functions produce no visible output when called directly. Run xs test to discover and execute them.

@scoped on a let or var tells the checker the value must not outlive the current block, which lets the runtime skip cycle detection for that value.

Generic type params

scratch.xs

fn identity<T>(x: T) -> T {
  return x
}

fn first<T>(arr: [T]) -> T {
  return arr[0]
}

println(identity(42))
println(first(["a", "b", "c"]))

Edit this page on GitHub ->