Reads like plain English. Checked before it runs.

let name = "Zeno"            # let: set once
var count = 3                # var: can change
count = count + 1            # plain = updates it
const LIMIT = 10             # const: fixed when the program is built

let ports: list[int] = [80, 443, 8080]   # a type, only where you want one
print(name, count, LIMIT, ports)

Zeno 4 10 [80, 443, 8080]

function area(width: float, height: float) -> float {
    return width * height
}

function loose_area(width, height) {     # the same, with no types written
    return width * height
}

function greet(who: str, excited: bool = false) -> str {
    if excited {
        return f"Hello, {who}!"
    }
    return f"Hello, {who}."
}

let triple = function(n) { return n * 3 }   # functions are values
print(area(2.0, 3.5), loose_area(2, 3))
print(greet("Achilles"), greet("tortoise", excited=true))
print([1, 2, 3].map(triple), [n * n for n in range(6) if n % 2 == 0])

7.0 6
Hello, Achilles. Hello, tortoise!
[3, 6, 9] [0, 4, 16]

enum Shape {
    Circle(radius: float)
    Rect(width: float, height: float)
    Dot
}

function area(shape: Shape) -> float {
    match shape {
        case Circle(r) { return 3.14159 * r * r }
        case Rect(w, h) { return w * h }
    }
}

print(area(Rect(2.0, 3.0)))

error: this `match` does not handle Dot. Add a `case` for it, or a final `case _`
 --> shapes.zeno:8:5
  |
8 |     match shape {
  |     ^

1 error found. Nothing was run.

function parse_port(text: str) -> int raises ValueError {
    let port = int(text)             # int() may raise; it passes up
    if not 1 <= port <= 65535 {      # comparisons chain, as in maths
        raise ValueError("port out of range")
    }
    return port
}

try {
    print("listening on", parse_port("8080"))
    print("listening on", parse_port("99999"))
} except ValueError as err {
    print(f"error: {err}")
}

listening on 8080
error: port out of range

function find_user(id: int) -> str or none {
    if id == 1 {
        return "partha"
    }
    return none
}

let user = find_user(1)
print(user.upper())              # not allowed: it might be none

if user is not none {
    print(user.upper())          # allowed inside this check
}

error: this is str or none. Check it with `is not none` before using `.upper`
 --> users.zeno:9:7
  |
9 | print(user.upper())              # not allowed: it might be none
  |       ^

1 error found. Nothing was run.

from time import sleep

function blink_for(delay: ms) -> str {
    sleep(delay)
    return f"waited {delay}"
}

print(blink_for(20 ms))
print(3.3 V > 2.9 V)
print(blink_for(20))

error: `delay` of `blink_for` should be a quantity in ms, but this is int
  --> delay.zeno:10:17
   |
10 | print(blink_for(20))
   |                 ^

1 error found. Nothing was run.

class Header {
    sensor: u8          # one byte in the compiled struct
    value: u16          # two bytes
}

let total = 200 + 100            # arithmetic gives a full int: nothing wraps by accident
print(total, u8.wrap(total))     # wrapping is something you ask for
let flags = 0b1010 << 4 | 0x03   # the operators every datasheet uses
print(f"{flags:02x}", Header(sensor=3, value=u16(64000)))
print(u8(total))                 # 300 does not fit in a byte

300 44
a3 Header(sensor=3, value=64000)
error: uncaught OverflowError: 300 does not fit in a u8 (0 to 255)
  --> packet.zeno:10:7
   |
10 | print(u8(total))                 # 300 does not fit in a byte
   |       ^

class Stack[T] {
    items: list[T]

    function push(self, item: T) {
        self.items.append(item)
    }

    function top(self) -> T or none {
        if len(self.items) == 0 {
            return none
        }
        return self.items[len(self.items) - 1]
    }
}

function largest[T](items: list[T]) -> T {
    var best = items[0]
    for item in items {
        if item > best {
            best = item
        }
    }
    return best
}

let bytes: Stack[u8] = Stack([])
bytes.push(u8(72))
print(bytes.top(), largest([3.1 V, 3.3 V, 2.9 V]), largest(["boot", "ready"]))

72 3.3 V ready

owned class Frame {
    channel: int
    samples: owned list[int]
}

function capture(channel: int) -> Frame {
    let samples: owned list[int] = [n * channel for n in range(4)]
    return Frame(channel, samples)       # samples moves into the frame
}

function average(samples: borrow list[int]) -> int {   # only looks
    return sum(samples) // len(samples)
}

function send(frame: Frame) -> int {     # takes the frame over, and frees it
    return len(frame.samples)
}

let frame = capture(7)
print(average(frame.samples))
print(send(frame))
print(frame.channel)

error: `frame` was given away on line 21 and holds nothing now. Lend it instead (a `borrow` parameter), or use it before it goes
  --> frame.zeno:22:7
   |
22 | print(frame.channel)
   |       ^

1 error found. Nothing was run.