Signum is designed for programs where correctness is more valuable than ceremony. The language takes three positions:
- No mutable globals. There is nowhere for hidden state to hide. Every reducer's behaviour is a function of its argument.
- Pipes over calls.
x >> a >> breads left-to-right and composes without punctuation. The call-tree of a Signum program is the pipe chain. - Rules over objects. There are no classes. A reducer is the single callable form; polymorphism is argument shape.
How it compares
The same program — grade a score as A/B/C/F — written three ways:
| Style | Python-like | Signum |
|---|---|---|
| Function | def grade(score): | @ grade : a |
| Branch | if score >= 90: return "A" | ? (n >= 90) ("A" >> se_ok) -> .. |
| Return | return keyword | -> arrow |
| Side effects | Allowed anywhere | Only through named io.* builtins |
| Call style | print(grade(x)) | x >> grade >> print |
What determinism buys you
- Reproducible builds — identical reducers write identical SBN bytes, so a cache hit is a byte-for-byte match.
- Cross-backend parity — the
test-aotgate catches any divergence between interpreter and compiled output. - Debuggable without a debugger — reading a value's path through the pipe chain tells you what happened. There is no time-dependent state to step through.
The payoff is a language where "same input, same output" is a type-system-level guarantee rather than an aspiration — and where neural-symbolic workloads (beliefs, observations, causal chains) can be expressed as pure data transforms over dicts.