Language Reference

Mental Model

If you know Python or Haskell, override these habits first:

Core axioms:

• No def, no return — name args = body; last expression is the result
• Offside rule — indentation defines blocks (like Python)
• Immutable — all bindings are immutable
• Strict — eager evaluation, left-to-right (not lazy like Haskell)
• Types inferred — annotations are optional: f : Int -> Int

Types

Hindley-Milner type inference. You rarely need to write types.

Primitive Types

Composite Types

Type Aliases

type Pos = {x : Int, y : Int}
type Transform = Int -> Int
type Pair a b = {fst : a, snd : b}

Functions & Pattern Matching

Functions are defined with name args = body. Multiple equations define pattern matching (first match wins):

-- Simple function
double x = x * 2

-- Pattern matching: multiple equations
fac 0 = 1
fac n = n * fac (n - 1)

-- Wildcard pattern
describe 0 = "zero"
describe _ = "other"

-- Cons pattern (parentheses required!)
head (x:_)  = x
tail (_:xs) = xs
isEmpty []  = true
isEmpty _   = false

-- Lambda
square = \x -> x * x

-- Type annotation (optional)
add : Int -> Int -> Int
add x y = x + y

Verification Contracts

clamp : Int -> Int
  requires x >= 0
  requires x <= 1000
  ensure result >= 1
  ensure result <= 100
clamp x = ? x < 1 -> 1 : ? x > 100 -> 100 : x

• requires — precondition, checked before body executes
• ensure — postcondition, checked after return; result in scope
• Violation → runtime error

Operators

Precedence from lowest to highest (13 levels). Every operator = 1 BPE token.

Control Flow

Conditional: ? -> :

The ternary operator replaces if/else:

abs x = ? x < 0 -> -x : x

-- Multi-branch chain
fizzbuzz n =
  ? n % 15 == 0 -> "FizzBuzz"
  : ? n % 3 == 0 -> "Fizz"
  : ? n % 5 == 0 -> "Buzz"
  : show n

Local Bindings

hyp a b =
  a2 = a * a
  b2 = b * b
  a2 + b2

Pipes

result = [1 2 3 4 5 6 7 8 9 10]
  |> filter (\x -> x % 2 == 0)
  |> map (\x -> x * x)
  |> sum
-- result = 220

Sequencing

-- Use ; to sequence side effects
main = print "a" ; print "b" ; print "c"

Lists

xs    = [1 2 3 4 5]       -- space-separated, NO commas
empty = []
r     = [1..10]            -- range (inclusive)
both  = [1 2] ++ [3 4]    -- concatenation: [1 2 3 4]
ys    = 1 : [2 3]          -- cons (prepend): [1 2 3]

-- List comprehension
evens = [x | x <- [1..20], x % 2 == 0]
pairs = [[a b] | a <- [1 2], b <- ["x" "y"]]

-- Pattern matching
only [x]     = x           -- exactly one element
sum3 [a b c] = a + b + c   -- exactly three

Gotcha: : is both cons and else-branch in ?->:. In then-branch, parenthesize cons: ? cond -> (x:xs) : rest

Records

-- Create
pt = {x = 3, y = 4}

-- Field access
px = pt.x                          -- 3

-- Nested
circle = {center = {x = 0, y = 0}, radius = 5}
cx = circle.center.x               -- 0

-- Punning: {x, y} = {x = x, y = y}
point x y = {x, y}

-- Pattern matching (destructure)
dist {x, y} = x * x + y * y

-- Record update (spread syntax)
move_x pt dx = {...pt, x = pt.x + dx}

Algebraic Data Types

-- Define sum types
Maybe a = Just a | None
Shape = Circle Float | Rect Float Float | Point

-- Construct
x = Just 42
s = Circle 3.0

-- Pattern match
fromMaybe def None     = def
fromMaybe _   (Just x) = x

area (Circle r)  = r * r
area (Rect w h)  = w * h
area Point       = 0

-- Derive
Color = Red | Green | Blue derive (Show, Eq, Ord)

Type Classes

-- Define a trait
trait Show a
  show : a -> String

-- Implement for a type
Color = Red | Green | Blue

impl Show Color
  show Red   = "red"
  show Green = "green"
  show Blue  = "blue"

-- Constrained implementation
impl Show (Maybe a) ? Show a
  show None     = "None"
  show (Just x) = "Just " ++ show x

Modules

-- Single-file module
mod Math
  square x = x * x
  pi = 3.14159

use Math (square pi)        -- selective import
use Math (*)                -- wildcard import

-- Multi-file
-- main.sno
import "math.sno"
use Math (square)
main = square 5

Error Handling

-- Result type (from prelude)
Result a e = Ok a | Err e

safe_div x 0 = Err "division by zero"
safe_div x y = Ok (x / y)

-- Chain with and_then
parse_and_double input =
  parse input |> and_then (\n -> safe_div n 2)

-- Monadic bind with <-
main =
  a <- safe_div 10 2
  b <- safe_div a 3
  Ok (a + b)

-- Unrecoverable error
head []    = error "empty list"
head (x:_) = x

String Interpolation

name = "world"
msg = "Hello ${name}"              -- "Hello world"
sum = "${a} + ${b} = ${a + b}"     -- expressions allowed
esc = "\$ is literal dollar"       -- escape with \$

Standard Library

List Operations

String Operations

Math

Type Conversion

Result Combinators (prelude)

JSON

I/O & Networking

Console

File I/O

TCP Networking

-- Minimal HTTP server
handle fd =
  req = fd_readline fd
  fd_write fd "HTTP/1.0 200 OK\r\n\r\nHello!"
  fd_close fd

main =
  listener = tcp_listen 8080
  loop l = handle (tcp_accept l) ; loop l
  loop listener

HTTP Client

HTTP only — no HTTPS. Use fd_popen "curl https://..." for HTTPS.

Environment

Concurrency

-- Structured concurrency
main = scope {
  c = chan ()
  spawn (send c 42)
  print (recv c)        -- prints 42
}

-- Parallel map
result = pmap (\x -> x * x) [1 2 3 4 5]

Time

Testing

-- Doctests (in doc comments)
--- Compute factorial.
--- example: fact 5 == 120
fact 0 = 1
fact n = n * fact (n - 1)

-- Unit tests
test "base case" = fact 0 == 1
test "fact 10"   = fact 10 == 3628800

-- Property tests
test "reverse involution" =
  prop xs -> reverse (reverse xs) == xs
test "positive factorial" =
  prop n -> fact n >= 1 when n >= 0 && n <= 10

Run: synoema test file.sno or synoema test directory/

CLI Reference

Interpreter vs JIT

Use run for development and I/O. Use jit for performance.