The Jo Programming Language

pattern Positive: Int = case x if x > 0

A guard pattern binds no variables — it only tests a condition. Positive refines any Int to one that satisfies x > 0, giving the constraint a name that can be reused across every match site.

pattern P(params): Type

Parameters declare the values a pattern extracts. When Student(name, sex, age) matches, all three fields are bound — the pattern both tests and destructures in one reusable definition.

then s = std.name, sex = std.sex, ...

The then clause assigns each parameter to an extracted value. All parameters must be bound in every case — a compile-time guarantee that extraction is complete.

..pos while Positive

Collect list elements into pos as long as the named pattern Positive matches, then bind the remainder to rest. One declarative case replaces a manual accumulator loop.

if foo() is Some(n) && n > 0 then

An is check narrows the type in the branch — no cast needed, no shadow variable. Works with any type, pattern, or union case.

`(?s)<code>(?<prog>.*)</code>`

Regex named capture groups become typed local variables in the then branch. No manual group extraction or index lookup — the compiler wires it up.

String :- [adapters]

A duck type is structurally equivalent to another type, with named adapter functions for auto-conversion. The compiler inserts the right adapter at each call site — no wrapper boilerplate.

.toString

Member adapters (.toString) match any type that has the method. Named function adapters (intToStr) handle conversions that require extra logic.

extension … end

Extension definitions defines a new extension type with methods attached to the base type.

String :+ [m1]

Bind extension methods to the type. Base-type compatibility is checked when attached.