Jock

01 » Compiles to Nock

Every Jock program erases to a noun and a formula. Structs become right-nested tuples, enums become tagged cells, and the whole language bottoms out in twelve instructions.

var a: Bool = true;
a = false;
a

[8 [1 0] 7 [10 [2 1 1] 0 1] 0 2]

02 » Examples

A few programs from the examples folder — each one a complete, executable program.

struct PointState { x: Float64, y: Float64 };
class Point(PointState) impl Add, Sub {
  add(self: Self, p: Self) -> Self {
    Point( x: self.x + p.x, y: self.y + p.y )
  };
  sub(self: Self, p: Self) -> Self {
    Point( x: self.x - p.x, y: self.y - p.y )
  };
};
let p = Point( x: 101.0, y: 105.0 );
let q = Point( x: 42.0, y: 7.0 );
(p + q).x

func<T: Lt> insert(x: T, xs: List<T>) -> List<T> {
  match xs {
    (h, t) => if x < h { (x, xs) } else { (h, insert(x, t)) },
    _ => [x],
  }
};
func<T: Lt> isort(xs: List<T>) -> List<T> {
  match xs {
    (h, t) => insert(h, isort(t)),
    _ => ~,
  }
};
isort([5, 3, 8, 1, 9, 2])

enum Color { red, green, yellow };
struct LightState { c: Color };
func advance(c: Color) -> Color {
  match c {
    .red => Color.green,
    .green => Color.yellow,
    .yellow => Color.red,
  }
};
impl Show for Color {
  show(self: Color) -> String {
    match self {
      .red => "red",
      .green => "green",
      .yellow => "yellow",
    }
  };
};

struct KS { n: @ };
class Counter(KS) impl Kernel {
  load(self: Counter, old: *) -> Counter { old as! Counter };
  peek(self: Counter, p: *) -> * { self.n };
  poke(self: Counter, e: *) -> (List<Effect>, Counter) { (~, Counter( n: self.n + 1 )) };
};
Counter( n: 0 )

struct KS2 { n: @, total: @ };
class CounterV2(KS2) impl Kernel {
  load(self: CounterV2, old: *) -> CounterV2 { CounterV2( n: old as! @, total: 100 ) };
  peek(self: CounterV2, p: *) -> * { (self.n, self.total) };
  poke(self: CounterV2, e: *) -> (List<Effect>, CounterV2) { (~, CounterV2( n: self.n + 1, total: self.total + 1 )) };
};
CounterV2( n: 0, total: 100 )

03 » Repositories

Jock is a one-man rewrite in active development. The public alpha remains the reference for the original language release by Zorp in June 2025; new feature work is happening in the recommenced repository as of August 2026.

04 » Keywords

defer is reserved (%defer) but its runtime semantics aren't pinned yet, so it's left off the table above rather than shown with an invented example.

05 » Punctuation & operators

Every built-in operator has an ASCII-first spelling. The punctuator inventory is $jpunc in /sur/jock; the precedence table was frozen 2026-08-06 and changes to it are version boundaries, not amendments.

The adjacency law. Postfix forms bind only when glued. f(x) is a call and f (x) is not; xs[0] is an index and xs [0] is not; Point( x: 1 ) is construction while a free-standing { … } is a block. An un-glued ( after a complete expression is always a parse error with a hint — never a different meaning.

** and unary - are reserved through 1.0: they lex and parse at frozen precedence but refuse at desugar, so their placement cannot be renegotiated when they land. Ten Unicode glyphs (⊛ ∩ ⊗ ∘ ⋅ ∪ ⊕ ⊖ ± ⊂) are trait-only: the language lexes and parses them and assigns no meaning, so a library supplies one through the ops registry.

05 » Punctuators

Everything the language spells with punctuation rather than a word. Each glyph has one meaning; where two readings were possible the grammar picks one and refuses the other loudly, so nothing here is context-sensitive.

The adjacency law. A postfix (, [ or { attaches to what precedes it iff no whitespace separates them. So fib(n) is a call and fib (n) is not; Point( x: 1 ) is construction while a free-standing { … } is a block. An un-glued one is always a parse error with a hint, never a different meaning.

Unicode aliases. × ÷ ± ⊕ ⊗ ⊖ ∘ · ∩ ∪ ∈ ⊂ ⊃ ⊛ lex as ordinary punctuators — 3 × 4 and 2 ∈ s are the arithmetic and membership you would expect. ASCII spellings are always available.

Reserved, and loud about it. & is reserved through 1.0 and every occurrence refuses with prose — && is not Jock, the connectives are the words and, or, not. A glued || refuses the same way; single | stays the type-union punctuator. $(…) is reserved for recursion re-entry with edits but has no parser path yet, so recursion today is by name for a func and bare recur for a loop. Unary - and ** are reserved through 1.0.