// STRYKE — FULL REFERENCE

# pmap

Parallel map powered by rayon's work-stealing thread pool. Every element of the input list is processed concurrently across all available CPU cores, and the output order is guaranteed to match the input order. This is the primary workhorse for CPU-bound transforms in stryke — use it whenever you have a pure function and a large list. Pass progress => 1 to get a live progress bar on STDERR for long-running jobs.

Two equivalent surface syntaxes: • Block form — pmap BLOCK LIST — element bound to _ • Bare-fn form — pmap FUNC, LIST — single-arg function name as first argument

# Block form
my @out = pmap { _ * 2 } 1:1_000_000
my @hashes = pmap sha256 @blobs, progress => 1
1:100 |> pmap { fetch("https://api.example.com/item/$_") } |> e p

# Bare-fn form (works for builtins and user-defined subs)
my @hashes = pmap sha256, @blobs, progress => 1
fn dbl = _ * 2
my @r = pmap dbl, (1:1_000_000)

# pmaps

Streaming parallel map — returns a lazy iterator that processes items across all CPU cores using a persistent worker-thread pool. Unlike pmap which eagerly collects all results into an array, pmaps yields results as they complete through a bounded channel, so downstream consumers see output immediately. Output order is non-deterministic (completion order). Each worker thread reuses a single interpreter instance, making it faster than pmap for large inputs.

Best for: • Pipelines with take/head — avoids processing the full list • Very large inputs where holding all results in memory is impractical • Streaming pipelines where you want progressive output

range(0, 1e9) |> pmaps { _ * 2 } |> take 10 |> ep
t 1:1e6 pmaps { expensive(_) } ep
range(0, 1e6) |> pmaps { fetch("https://api/item/$_") } |> pgreps { _->{ok} } |> ep

# pmap_chunked

Parallel map that groups input into contiguous batches of N elements before distributing to threads. This reduces per-item scheduling overhead when the per-element work is very cheap (e.g. a few arithmetic ops). Each thread receives a slice of N consecutive items, processes them sequentially within the batch, then returns the batch result. Use this instead of pmap when profiling shows rayon overhead dominates the actual computation.

my @out = pmap_chunked 100, { _ ** 2 } 1:1_000_000
my @parsed = pmap_chunked 50, { json_decode } @json_strings

# pgrep

Parallel grep that evaluates the filter predicate concurrently across all CPU cores using rayon. The result preserves the original input order, so it is a drop-in replacement for grep on large lists. Best suited for predicates that do meaningful work per element — if the predicate is trivial (e.g. a single regex on short strings), sequential grep may be faster due to lower scheduling overhead.

Two equivalent surface syntaxes: pgrep { BLOCK } LIST or pgrep FUNC, LIST.

# Block form
my @matches = pgrep { /complex_pattern/ } @big_list
my @primes = pgrep { is_prime } 2:1_000_000
@files |> pgrep { -s _ > 1024 } |> e p

# Bare-fn form
fn Demo::even = _ % 2 == 0
my @e = pgrep Demo::even, 1:10  # (2,4,6,8,10)

# pgreps

Streaming parallel grep — returns a lazy iterator that filters items across all CPU cores. Unlike pgrep which eagerly collects all matching items, pgreps yields matches as they are found through a bounded channel. Output order is non-deterministic (completion order). Each worker thread reuses a single interpreter instance.

range(0, 1e6) |> pgreps { is_prime(_) } |> take 100 |> ep
t 1:1e9 pgreps { _ % 7 == 0 } take 10 ep

# pfor

Parallel foreach that executes a side-effecting block across all CPU cores with no return value. Use this when you need to perform work for each element (writing files, sending requests, updating shared state) but don't need to collect results. The block receives each element as _. Iteration order is non-deterministic, so the block must be safe to run concurrently.

Two equivalent surface syntaxes: pfor { BLOCK } LIST or pfor FUNC, LIST.

# Block form
pfor { write_report } @records
pfor { compress_file } glob("*.log")
@urls |> pfor { fetch
    p "done: $_" }

# Bare-fn form
fn task = ep "did $_"
pfor task, (1, 2, 3)

# psort

Parallel sort that uses rayon's parallel merge-sort algorithm. Accepts an optional comparator block; the two sort candidates are _ and _1. For large lists (10k+ elements), this significantly outperforms the sequential sort by splitting the array, sorting partitions in parallel, and merging. The sort is stable — equal elements retain their relative order.

my @sorted = psort { _ <=> _1 } @big_list
my @by_name = psort { (_)->{name} cmp (_1)->{name} } @records
@nums |> psort { _ <=> _1 } |> e p

# pcache

Parallel memoized map — each element is processed concurrently, but results are cached by the stringified value of _ so duplicate inputs are computed only once. This is ideal when your input list contains many repeated values and the computation is expensive. The cache is a concurrent hash map shared across all threads, so there is no lock contention on reads after the first computation.

Two equivalent surface syntaxes: pcache { BLOCK } LIST or pcache FUNC, LIST.

# Block form
my @out = pcache { expensive_lookup } @list_with_dupes
my @resolved = pcache { dns_resolve } @hostnames

# Bare-fn form
my @resolved = pcache dns_resolve, @hostnames

# preduce

Parallel tree-fold using rayon's reduce — splits the list into chunks, reduces each chunk independently, then merges partial results. The combining operation must be associative (e.g. +, *, max); non-associative ops will produce incorrect results. Much faster than sequential reduce on large numeric lists because the tree structure allows O(log n) merge depth across cores.

my $total = preduce { _ + _1 } @nums
my $biggest = preduce { _ > _1 ? _ : _1 } @vals
my $product = preduce { _ * _1 } 1:100

# preduce_init

Parallel tree-fold with an explicit identity element. Same engine as preduce (rayon's reduce_with), but INIT seeds every chunk so empty / single-element inputs return a sensible value instead of undef. The combining operation must be associative AND INIT must be its identity (INIT ⊕ x == x); otherwise different chunk boundaries produce different sums.

my $total   = preduce_init 0, { _ + _1 } @nums      # sum, identity 0
my $product = preduce_init 1, { _ * _1 } @nums      # product, identity 1
my $biggest = preduce_init -inf, { _ > _1 ? _ : _1 } @vals

# Histogram merge — identity is the empty hash.
my %h = %{ preduce_init +{}, { merge_hash(_, _1) } @per_chunk_hashes }

Without an identity, prefer preduce (no init) or pmap_reduce (fused mapper + reducer).

See also: preduce, pmap_reduce, reduce (sequential), fold (sequential with init).

# pmap_reduce

Fused parallel map + tree reduce. Each input element is mapped in parallel via rayon; results are combined pairwise by the reducer block. The reducer must be associative ((a⊕b)⊕c == a⊕(b⊕c)) — order of pairwise combines is not fixed.

# Two-block form: pmap_reduce { MAPPER } { REDUCER } LIST
my $sum = pmap_reduce { _ * 2 } { _ + _1 } @list

# Chunked aggregation — mapper returns a per-chunk arrayref, reducer merges.
my $grads = @batches |> pmap_reduce {
    my $idxs = _
    [ batch_grad($w, $b, $XS, $YS, $idxs), len(@$idxs) ]
} {
    [ _->[0] + _1->[0], _->[1] + _1->[1] ]
}

Caveats:

• rand() in the mapper is parallel-correlated. Per-task rand() calls across workers produce statistically correlated values; prefer chunked Monte-Carlo where each task runs its own inner loop.

See also: pmap (eager parallel map), pmaps (streaming), par_reduce (verbose builder).

# pany

pany { COND } @list — parallel short-circuit any. Splits the list across cores via rayon, evaluates COND on each element, returns truthy as soon as any chunk reports a hit and cancels the rest. Returns the matching element (truthy) or 0 (no match).

# Found in O(N/cores), often much faster — early-stops once any worker hits.
if (pany { _ > 1_000_000 } @samples) { p "found a large sample" }
pany { is_prime(_) } 10**9 : 10**9 + 50    # "is there a prime in this range?"

See also: pall (parallel all), pfirst (return the matching value), any (sequential), pgrep (full filter).

# pfirst

pfirst { COND } @list — parallel first. Like pany but returns the matching element rather than just a truthy flag. Workers run concurrently across chunks; the first hit (by *completion order*, not input order) wins and the remaining workers are cancelled. Returns undef if no element matches.

my $hit = pfirst { _->{status} eq "FAILED" } @records
my $prime = pfirst { is_prime(_) } 10**12 : 10**12 + 1000

Note: output is non-deterministic when multiple elements match — workers race. For first-by-input-order use sequential first or pfirst_in_order (where supported).

See also: pany, first, pgrep.

# puniq

puniq @list — parallel deduplication. Returns the unique elements of @list, with the original input order preserved (first occurrence wins). Elements are keyed by stringification ("$_"), so 1 and "1" deduplicate together. Backed by a concurrent hash set.

my @uniq    = puniq @log_lines
my @hosts   = puniq map { _->{host} } @records
my @hashes  = puniq pmap sha256, @files     # parallel hash + dedup

For exact-key (no stringification) dedup, build the set manually with mysync %seen + pmaps. For *count* of unique items use hll_count (HyperLogLog) which is O(1) memory.

See also: uniq (sequential), dedup, hll_count.

# pflat_map

Parallel flat-map: map + flatten results. Each element produces zero or more output values via the block/function, and the outputs are concatenated in input order.

Two equivalent surface syntaxes: pflat_map BLOCK LIST or pflat_map FUNC, LIST.

# Block form
my @out = pflat_map expand @list

# Bare-fn form
fn expand = (_, _ * 10)
my @r = pflat_map expand, (1, 2, 3)   # (1, 10, 2, 20, 3, 30)

# pflat_maps

Streaming parallel flat-map. Like pmaps but each block iteration may emit zero or more values, all of which are spliced into the downstream iterator (no intermediate vec). Runs on the persistent worker-thread pool, output order is non-deterministic, and downstream take/head cancels remaining work.

# One-to-many expansion in parallel
range(0, 1e6) |> pflat_maps { [_, _ * 10] } |> ep

# Drop and explode: yield only odd-derived pairs
1:1_000_000 |> pflat_maps { _ % 2 ? (_, _ * _) : () } |> take 20 |> ep

# Tokenize a big corpus in parallel
glob("*.txt") |> pflat_maps { slurp(_) |> split /\s+/ } |> pgreps { len _ } |> ep

For eager flat-map use pflat_map (returns a vec). For sequential lazy flat-map use flat_maps.

See also: pmaps, pflat_map, flat_maps, flat_map.

# fan

Execute BLOCK or FUNC N times in parallel (_ = index 0..N-1). With no count, defaults to the rayon pool size (stryke -j).

Two equivalent surface syntaxes: • Block form — fan N { BLOCK } or fan { BLOCK } • Bare-fn form — fan N, FUNC or fan FUNC

# Block form
fan 8 { work(_) }
fan { work(_) } progress => 1

# Bare-fn form
fn tick = ep "tick $_"
fan 8, tick
fan tick, progress => 1   # uses pool size

# fan_cap

Like fan but captures return values in index order. Two surface syntaxes: fan_cap N { BLOCK } or fan_cap N, FUNC.

# Block form
my @results = fan_cap 8 { compute(_) }

# Bare-fn form
fn compute = _ * _
my @squares = fan_cap 8, compute

# mysync

Declare shared variables for parallel blocks (Arc<Mutex>). varsync is a Kotlin-style alias for mysync — same way var aliases my. Both spellings parse to the same StmtKind::MySync AST node and produce byte-identical bytecode; pick whichever spelling fits the calling style.

mysync  $counter = 0       # canonical spelling
varsync $counter = 0       # Kotlin-style alias — identical semantics
fan 10000 { $counter++ }   # always exactly 10000
mysync @results
varsync %histogram

Compound ops (++, +=, .=, |=, &=) are fully atomic on shared scalars. Both spellings reflect under %k with category concurrency.

See also: oursync (package-global counterpart), var / val (the my aliases that established the convention).

# oursync

Package-global counterpart of mysync / varsync. Same Arc<Mutex> backing, but the binding is keyed by the package-qualified stash name (Pkg::x) so all packages and parallel workers share one cell.

package Counter
oursync $total = 0
fn bump { $total++ }
package main
fan 10000 { Counter::bump() }
p $Counter::total   # 10000

Use oursync for cross-package shared state; use mysync / varsync for lexically scoped shared state.

# async

async { BLOCK } — schedule a block for execution on a background worker thread and return a task handle immediately.

The block begins executing as soon as a thread is available in stryke's global rayon thread pool, while the calling code continues without blocking. To retrieve the result, pass the task handle to await, which blocks until the task completes and returns its value. If the block panics, the panic is captured and re-raised at the await call site. Use async for fire-and-forget background work, overlapping I/O with computation, or launching multiple independent tasks that you later join. For structured fan-out with index-based parallelism, prefer fan or fan_cap instead.

my $task = async { long_compute() }
do_other_work()
my $val = await $task

# Overlapping multiple fetches:
my @tasks = map { async { fetch("https://api.example.com/$_") } } 1:10;
my @results = map { await _ } @tasks

# spawn

spawn { BLOCK } — Rust-style alias for async; schedules a block on a background thread and returns a joinable task handle.

This is identical to async in every respect — same thread pool, same semantics, same await for joining. The name exists for developers coming from Rust's tokio::spawn or std::thread::spawn who find spawn more natural. Use whichever reads better in your code; mixing async and spawn in the same program is perfectly fine since they share the same underlying pool.

my $task = spawn { expensive_io() }
my $val = await $task

my @handles = map { spawn { process } } @items;
my @out = map { await _ } @handles

# await

await $task — block the current thread until an async/spawn task completes and return its result value.

If the background task has already finished by the time await is called, the result is returned immediately with no scheduling overhead. If the task panicked, await re-raises the panic as a die in the calling thread, preserving the original error message and backtrace. You can await a task exactly once; calling await on an already-joined handle is a fatal error. For waiting on multiple tasks, simply map over the handles — stryke does not yet provide a join_all primitive, but map await @tasks achieves the same effect.

my $task = async { 42 }
my $result = await $task              # 42

# Await with error handling:
my $t = spawn { die "oops" }
eval { await $t }                     # $@ eq "oops"

# pchannel

pchannel(N) — create a bounded multi-producer multi-consumer (MPMC) channel with capacity N, returning a ($tx, $rx) pair.

The transmitter $tx supports ->send($val) which blocks if the channel is full (backpressure). The receiver $rx supports ->recv which blocks until a value is available, and ->try_recv which returns undef immediately if the channel is empty. Both ends can be cloned and shared across threads — clone $tx with $tx->clone to create additional producers, or clone $rx for additional consumers. When all transmitters are dropped, ->recv on the receiver returns undef to signal completion. Use pchannel to build producer-consumer pipelines, rate-limited work queues, or to communicate between async/spawn tasks.

my ($tx, $rx) = pchannel(100)
async { $tx->send(_) for 1:1000
    undef $tx }
while (defined(my $val = $rx->recv)) {
    p $val
}

# Multiple producers:
my ($tx, $rx) = pchannel(50)
for my $i (1:4) {
    my $t = $tx->clone
    spawn { $t->send("from worker $i: _") for 1:100 }
}
undef $tx  # drop original so channel closes when workers finish

# pselect

pselect(@receivers) / pselect(timeout_ms => N, @receivers) — wait on multiple pchannel receivers; returns ($index, $value) for the first receiver to produce a value. Equivalent to Go's select { case v := <-ch1: … case v := <-ch2: … }.

The optional timeout_ms clause returns (-1, undef) if no receiver delivers within the deadline. Closed channels (all senders dropped) return (i, undef) so the caller can detect end-of-stream per receiver.

my ($tx_a, $rx_a) = pchannel(8)
my ($tx_b, $rx_b) = pchannel(8)
spawn { $tx_a->send($_) for 1:100 }
spawn { $tx_b->send($_ * 10) for 1:100 }
while (1) {
    my ($idx, $val) = pselect $rx_a, $rx_b
    last unless defined $val
    p "from #$idx: $val"
}

# With deadline:
my ($idx, $val) = pselect timeout_ms => 500, $rx_a, $rx_b

See also: pchannel, spawn, async, barrier.

# barrier

barrier(N) — create a synchronization barrier that blocks until exactly N threads have arrived at the wait point.

Each thread calls $bar->wait and is suspended until all N participants have reached the barrier, at which point all are released simultaneously. This is useful for coordinating phased parallel algorithms where all workers must complete step K before any worker begins step K+1. The barrier is reusable — after all threads are released, it resets and can be waited on again. Internally backed by a Rust std::sync::Barrier for zero-overhead synchronization.

my $bar = barrier(4)
for my $i (0:3) {
    spawn {
        setup_phase($i)
        $bar->wait                      # all 4 threads sync here
        compute_phase($i)
    }
}

# ppool

ppool(N, fn { ... }) — create a persistent thread pool of N worker threads, each running the provided subroutine in a loop.

The pool is typically paired with a pchannel: workers pull items from the channel's receiver, process them, and optionally send results to an output channel. Unlike pmap which is a one-shot parallel transform, ppool keeps threads alive for the lifetime of the pool, making it ideal for long-running server-style workloads, background drain loops, or scenarios where thread startup cost would dominate short-lived pmap calls. Workers exit when their input channel is closed (all transmitters dropped). The pool object supports ->join to block until all workers have finished.

my ($tx, $rx) = pchannel(100)
my $pool = ppool 4, fn {
    while (defined(my $job = $rx->recv)) {
        process($job)
    }
}
$tx->send(_) for @work_items
undef $tx                             # signal completion
$pool->join                           # wait for drain

# deque

deque LIST — create a double-ended queue initialized with the given elements.

A deque supports efficient O(1) insertion and removal at both ends via ->push_front($val), ->push_back($val), ->pop_front, and ->pop_back. It also supports ->len and iteration. Internally backed by a Rust VecDeque, it is ideal for sliding window algorithms, BFS traversals, or any scenario where you need fast access to both ends of a sequence.

my $dq = deque(1, 2, 3)
$dq->push_front(0)
$dq->push_back(4)
p $dq->pop_front                      # 0

# heap

heap LIST — create a min-heap (priority queue) from the given elements.

Elements are heapified on construction so that ->pop always returns the smallest element in O(log n) time. ->push($val) inserts a new element, also in O(log n). The heap supports ->peek to inspect the minimum without removing it, and ->len for the current size. Internally backed by a Rust BinaryHeap (inverted for min-heap semantics), it is the go-to structure for top-K queries, Dijkstra, and merge-K-sorted-lists problems.

my $h = heap(5, 3, 8, 1)
p $h->pop                             # 1 (smallest first)
p $h->peek                            # 3 (next smallest)
$h->push(0)

# set

set LIST — create a set (unique unordered collection) from the given elements.

Duplicate values are collapsed on construction so the set contains each value exactly once. The set object provides ->contains($val) for O(1) membership testing, plus ->union($s), ->intersection($s), ->difference($s), and ->len methods. Internally backed by a Rust HashSet for performance. Use to_set to convert an existing iterator into a set.

my $s = set(1, 2, 3, 2, 1)
p $s->contains(2)                     # 1
p $s->len                             # 3
my $both = $s->union(set(3, 4, 5))

# |>

Pipe-forward operator — threads LHS as first argument of RHS call.

"hello" |> uc |> rev |> p              # OLLEH
1:10 |> grep _ > 5 |> map _ * 2 |> e p
$url |> fetch_json |> json_jq '.name' |> p
"hello world" |> s/world/perl/ |> p     # hello perl

Zero runtime cost (parse-time desugaring). Binds looser than ||, tighter than ?:.

# thread

Thread-first macro — chain stages where the threaded value is injected as the first argument (like Clojure's ->).

~> @data grep { _ > 5 } map { _ * 2 } sort { _ <=> _1 } |> join "," |> p
~> " hello " tm uc rv lc ufc sc cc kc tj p  # short aliases
fn div = _0 / _1
~> 10 div(2) p                               # div(10, 2) = 5
~> 10 div(_, 2) p                           # explicit _ position: div(10, 2) = 5

Spellings: ~>, thread, t. Stages: bare function (uc, tm, …), function with block (map { … }, grep { … }), name(args) call where _ is the threaded-value placeholder, or >{} anonymous block. |> terminates the macro.

# ~>>

Thread-last macro — chain stages where the threaded value is injected as the last argument (like Clojure's ->>).

fn div = _0 / _1
~>> 10 div(2) p                              # div(2, 10) = 0.2
->> 10 div(_, 2) p                          # explicit _ overrides: div(10, 2) = 5

# Thread-last is useful for list-consuming functions:
fn first_n { @_[0..$_[-1]-1] }              # first_n(list, n)
~>> (1,2,3,4,5) first_n(3) p                 # first_n(1,2,3,4,5, 3) = (1,2,3)

Spellings: ~>>, ->>. The explicit _ placeholder always takes precedence.

# ~s>

Per-item streaming thread macro — each stage runs as an independent worker thread connected to the next via a bounded channel, so items flow through the pipeline concurrently without materializing intermediate arrays.

~s> [1, 2, 3, 4, 5] map { _ * 10 } map { _ + 1 }
~s> @lines map { json_decode } grep { _->{ok} } map { _->{val} }
~s> gen { yield_lines "huge.log" } map { parse } grep { /ERROR/ }

Use ~s> when stages have differing latencies (I/O + CPU mix) so faster workers can pull ahead. Output order is non-deterministic. The macro's final value is the count of items the last stage emitted. ~s>> is the thread-last variant.

See ~p> for chunk-parallel (vs per-item) execution and par_pipeline for the verbose builder form.

# ~p>

Chunk-parallel thread macro — splits the input into chunks, runs the entire pipeline on each chunk in parallel via rayon, and auto-merges chunk results. Equivalent to par_reduce { stage1 |> stage2 |> ... } SRC.

~p> c("**.rs") letters freq                              # histogram across all .rs
~p> @big map { _ * 2 } sum                               # parallel map+sum
~p> $huge letters freq ||> values |> sum                 # boundary: terse
~p> $huge letters freq |then| values |> sum              # boundary: english

The auto-merger picks a strategy by inspecting the first chunk's result type: hash-of-numbers merges key-wise with + (canonical histogram), numeric scalars sum, arrays concat, strings concat. Use ||> or |then| to switch back to sequential ~> mode for stages that operate on the merged whole. |> also terminates a ~p> macro. ~p>> is the thread-last variant.

# ~d>

Distributed thread macro — same chunk-block semantics as ~p> but ships the pipeline to a remote stryke cluster rather than running locally. Syntax: ~d> on $cluster SOURCE stage1 stage2 .... The on EXPR slot is mandatory — EXPR must evaluate to a value built by cluster(...) (see cluster builtin).

my $c = cluster(["host1", "host2", "host3:8022"])
~d> on $c c("**.parquet") map { parse_pq } map { transform } collect
~d> on $c @huge_urls map { fetch } grep { _->{status} == 200 } |> sum_bytes

Unlike ~p>, captures from the enclosing scope are restricted: mysync/atomic captures are rejected (the value can't cross the wire safely). Errors on remote workers are surfaced as a single aggregated error. ~d>> is the thread-last variant — threaded value injected as the last argument of each stage.

See cluster for cluster construction, ~p> for local chunk-parallel, pmap_on for the verbose builder form.

# par

Generic parallel-chunk evaluator. Splits the input list into chunks, runs BLOCK on each chunk in parallel with the chunk bound to _ / _0, and flattens chunk outputs into a single list. Callable in three shapes:

# 1. Top-level prefix form — yields a flat list
par { BLOCK } LIST
my @r = par { letters } "Hello, World 123"      # H e l l o W o r l d
my @s = par { map { _ ** 2 } _ } @huge           # parallel squares

# 2. Postfix-statement form — side-effecting, no return binding
{ BLOCK } par LIST                               # runs BLOCK per chunk
{ log_chunk(_) } par @huge

# 3. As a `~>` / `~>>` thread-macro stage
~> "abc def" par { letters }                     # a b c d e f
~> @huge par { map { _ ** 2 } |> sum } |> sum p  # parallel sum-of-squares

Each chunk gets a fresh sub-VM with the chunk bound to _ and _0. List-returning ops keep their values; the runtime auto-flattens. Use par_reduce when you need an explicit merge step rather than flat concat.

# par_reduce

Chunk-extract-merge thread-stage. The single-block form runs extract per chunk and auto-merges results by type (hash<num>→key-wise add, number→sum, array→concat, string→concat). The two-block form binds $a/$b in the explicit reducer.

~> "abc def abc" par_reduce { letters |> freq }      # canonical histogram merge
~> @nums par_reduce { sum }                          # parallel sum
~> "abcdefgh" par_reduce { length(_) } { $a + $b }   # explicit pairwise reducer

Below the chunk threshold the runtime falls back to single-chunk eval; the result must still match the bare extract block's output. Multi-chunk paths require the merger (auto or explicit) to be associative and commutative for correct results.

# ||>

Boundary marker that terminates the chunk-parallel section of a ~p> macro and switches the merged result into a sequential ~> continuation.

~p> "abc def abc" letters freq ||> values |> sum     # 9
~p> "abc def abc" letters freq |then| values |> sum  # 9 — readable form
~p> @data map { _ * 2 } sum ||> sqrt p               # parallel sum, sequential sqrt

Both spellings are byte-equivalent; ||> is terse, |then| reads in English. Use either when you need a post-merge stage that operates on the whole reduced value rather than per-chunk. |> also terminates a ~p> macro.

# pipeline

pipeline(@list) — wrap a list (or iterator) in a lazy pipeline object supporting chained ->map, ->filter, ->take, ->skip, ->flat_map, ->tap, and other transforms that execute zero work until a terminal method is called.

No intermediate lists are allocated between stages — each element flows through the full chain one at a time, making pipelines memory-efficient even on very large or infinite inputs. Terminal methods include ->collect (materialize to list), ->reduce { ... } (fold), ->for_each { ... } (side-effect iteration), and ->count. Pipelines compose naturally with stryke's |> operator: you can feed pipeline(...) output into further |> stages or vice versa. Use pipeline when you want explicit method-chaining style rather than the flat |> pipe syntax — both compile to the same lazy evaluation engine.

my @out = pipeline(@data)
  ->filter { _ > 0 }
  ->map { _ * 2 }
  ->take(10)
  ->collect

pipeline(1:1_000_000)
  ->filter { _ % 3 == 0 }
  ->map { _ ** 2 }
  ->take(5)
  ->for_each { p _ }                # 9 36 81 144 225

my $sum = pipeline(@scores)
  ->filter { _ >= 60 }
  ->reduce { _ + _1 }

# par_pipeline

par_pipeline(source => \@data, stages => [...], workers => N) — build a multi-stage parallel pipeline where each stage's map/filter block runs concurrently across N worker threads.

Unlike pmap which parallelizes a single transform, par_pipeline lets you define a sequence of named stages — each with its own block — that execute in parallel while preserving input order in the final output. Internally, stryke partitions the source into chunks, distributes them across workers, and pipelines the stages so that stage 2 can begin processing a chunk as soon as stage 1 finishes it, overlapping computation across stages. This is ideal for multi-step ETL workloads where each step is CPU-bound and the data volume is large. The workers parameter defaults to the number of logical CPUs.

my @results = par_pipeline(
    source  => \@raw_records,
    stages  => [
        { name => "parse",     map => fn { json_decode } },
        { name => "transform", map => fn { enrich } },
        { name => "validate",  filter => fn { _->{valid} } },
    ],
    workers => 8,
)

# par_pipeline_stream

par_pipeline_stream(source => ..., stages => [...], workers => N) — streaming variant of par_pipeline that connects stages via bounded pchannel queues instead of materializing intermediate arrays.

Each stage runs as an independent pool of workers, pulling from an input channel and pushing to an output channel. This gives true pipelined parallelism: stage 1 workers produce items while stage 2 workers consume them concurrently, bounded by channel capacity to prevent memory blowup. The streaming design makes this suitable for infinite or very large data sources (file streams, network feeds) where materializing the full dataset between stages is impractical. Results are emitted in arrival order by default; pass ordered => 1 to reorder them to match input order at the cost of buffering.

par_pipeline_stream(
    source  => fn { while (my $line = <STDIN>) { yield $line } },
    stages  => [
        { name => "parse", map => fn { json_decode } },
        { name => "score", map => fn { compute_score } },
    ],
    workers => 4,
    on_item => fn { p _ },           # process results as they arrive
)

# collect

collect ITERATOR — materialize a lazy iterator or pipeline into a concrete list.

Pipeline stages in stryke are lazy: chaining |> map {...} |> grep {...} builds up a deferred computation without consuming any elements. Calling collect forces evaluation and returns all results as a regular Perl list. This is the standard way to terminate a lazy chain when you need the full result in an array. Without collect, the iterator is consumed element-by-element by e, take, or other streaming sinks.

my @out = range(1,5) |> map { _ * 2 } |> collect
gen { yield _ for 1:3 } |> collect |> e p
my @data = stdin |> grep /INFO/ |> collect

# maps

maps { BLOCK } LIST — the lazy, streaming counterpart of map. Instead of materializing the entire output list, maps returns a pull iterator that evaluates the block on demand as downstream consumers request values. This makes it ideal for |> pipeline chains, especially when combined with take, greps, or collect. Use maps over map when working with large ranges, infinite sequences, or when you want to short-circuit processing early with take. Memory usage is constant regardless of input size.

1:10 |> maps { _ * 3 } |> take 4 |> e p
# 3 6 9 12
1:1_000_000 |> maps { _ ** 2 } |> greps { _ > 100 } |> take 3 |> e p

# greps

greps { BLOCK } LIST — the lazy, streaming counterpart of grep. Returns a pull iterator that only evaluates the predicate as elements are requested downstream. This is the preferred filtering function in |> pipelines because it avoids materializing intermediate lists. Combine with take to short-circuit early, or with maps and collect for full lazy pipelines. The block receives _ just like grep.

1:100 |> greps { _ % 7 == 0 } |> take 3 |> e p
# 7 14 21
@lines |> greps { /ERROR/ } |> maps { tm } |> e p

# filter

filter (alias fi) { BLOCK } LIST — stryke-native lazy filter that returns a pull iterator, functionally identical to greps but named for familiarity with Rust/Ruby/JS conventions. Use filter or greps interchangeably in |> chains; both are streaming and both set _ in the block. The result must be consumed with collect, e p, foreach, or another terminal. Prefer filter when writing stryke-idiomatic code; prefer grep/greps when porting from Perl.

my @big = 1:1000 |> filter { _ > 990 } |> collect
@big |> e p   # 991 992 993 994 995 996 997 998 999 1000
1:50 |> fi { _ % 2 } |> take 5 |> e p   # 1 3 5 7 9

# tap

tap { BLOCK } LIST — execute a side-effecting block for each element, then pass the element through unchanged.

The return value of the block is ignored; the original element is always forwarded to the next pipeline stage. This makes tap ideal for injecting logging, debugging, or metrics collection into the middle of a pipeline without altering the data flow. It is fully streaming and preserves element order.

1:5 |> tap { log_debug "saw: $_" } |> map { _ * 2 } |> e p
@files |> tap { p "processing: $_" } |> map slurp |> e p

# peek

peek ITERATOR — inspect the next element of an iterator without consuming it.

The peeked value is buffered internally so that the next call to ->next or pipeline pull returns the same element. This is useful for lookahead parsing, conditional branching on the next value, or implementing take_while-style logic manually. Calling peek multiple times without advancing the iterator returns the same value each time. Works with any stryke iterator including gen, range, stdin, and pipeline results.

my $g = gen { yield _ for 1:5 }
p peek $g                             # 1 (not consumed)
p $g->next                            # 1
p peek $g                             # 2

# tee

tee FILE, ITERATOR — write each element to a file as a side effect while passing it through the pipeline.

Every element that flows through tee is appended as a line to the specified file, and the element itself continues downstream unchanged. The file is opened once on first element and closed when the iterator is exhausted. This is the stryke equivalent of the Unix tee command, useful for auditing or logging intermediate pipeline results to disk.

1:10 |> tee "/tmp/log.txt" |> map { _ * 2 } |> e p
stdin |> tee "/tmp/raw.log" |> grep /ERROR/ |> e p

# take

take N, LIST / head N, LIST / hd N, LIST — return at most the first N elements.

In streaming mode, take pulls exactly N elements from the upstream iterator and then stops, so it short-circuits infinite or very large sources efficiently. This makes it safe to write range(1, 1_000_000) |> take 5 without allocating a million-element list. If the source has fewer than N elements, all of them are returned. The head and hd aliases mirror Unix head semantics.

1:100 |> take 5 |> e p               # 1 2 3 4 5
my @top = hd 3, @sorted
stdin |> hd 10 |> e p                 # first 10 lines

# tail

tail N, @list — returns the last N elements of the list. If N exceeds the list length, the entire list is returned. The alias tl is also available. This is the complement of head/take. In stryke, it works both as a function call and in |> pipelines.

my @t = tail 2, 1:5
@t |> e p   # 4 5
1:100 |> tl 3 |> e p  # 98 99 100

# drop

drop N, LIST / skip N, LIST / drp N, LIST — skip the first N elements and return the rest.

This operation is fully streaming: when used in a pipeline, the first N elements are consumed and discarded without buffering, and all subsequent elements flow through to the next stage. If the list contains fewer than N elements, the result is empty. The skip and drp aliases exist for readability in different contexts — all three compile to the same internal op.

1:10 |> drop 3 |> e p                # 4 5 6 7 8 9 10
my @rest = drp 2, @data
stdin |> skip 1 |> e p                # skip header line

# take_while

take_while { COND } LIST — emit leading elements while the predicate returns true, then stop.

The block receives each element as _. Elements are emitted as long as the predicate holds; the moment it returns false, the pipeline terminates immediately without consuming further input. This short-circuit behavior makes take_while efficient on infinite iterators and large streams. It is the complement of drop_while.

1:10 |> take_while { _ < 5 } |> e p # 1 2 3 4
stdin |> take_while { !/^END/ } |> e p

# drop_while

drop_while { COND } LIST — skip leading elements while the predicate returns true, then emit everything after.

The block receives each element as _. Once the predicate returns false for the first time, that element and all remaining elements pass through unconditionally — the predicate is never consulted again. This is streaming: elements are tested one at a time without buffering. Useful for skipping headers, preamble, or sorted prefixes in data streams.

1:10 |> drop_while { _ < 5 } |> e p # 5 6 7 8 9 10
@log |> drop_while { /^ #/ } |> e p    # skip comment header

# reject

reject { BLOCK } LIST — stryke-native streaming inverse of filter/greps. It keeps only the elements for which the block returns false. This reads more naturally than filter { !(...) } when the condition describes what you want to exclude rather than what you want to keep. Like filter and greps, it returns a lazy iterator suitable for |> chains. The block receives _ as the current element.

1:10 |> reject { _ % 3 == 0 } |> e p
# 1 2 4 5 7 8 10
@files |> reject { /\.bak$/ } |> e p   # skip backups

# compact

compact (alias cpt) — stryke-native streaming operator that removes undef and empty-string values from a list or iterator. This is a common data-cleaning step when dealing with parsed input, optional fields, or split results that produce empty segments. It is equivalent to greps { defined(_) && _ ne "" } but more concise and faster because the check is inlined in Rust. Numeric zero and the string "0" are preserved since they are defined and non-empty.

my @raw = (1, undef, "", 2, undef, 3)
@raw |> compact |> e p   # 1 2 3
split(/,/, "a,,b,,,c") |> cpt |> e p   # a b c

# concat

concat (alias chain) — stryke-native streaming operator that concatenates multiple lists or iterators into a single sequential iterator. Pass array references and they will be yielded in order without copying. This is useful for merging data from multiple sources into a unified pipeline. The operation is lazy: each source is drained in turn, so memory usage stays proportional to the largest single element, not the total.

my @a = 1:3
my @b = 7:9
concat(\@a, \@b) |> e p   # 1 2 3 7 8 9
my @c = ("x")
concat(\@a, \@b, \@c) |> maps { uc } |> e p

# enumerate

enumerate ITERATOR / en ITERATOR — yield [$index, $item] pairs from a streaming iterator.

Each element is wrapped as [$index, $item] where the index starts at 0 and increments for each element. Unlike with_index which returns [item, index], enumerate uses the Rust/Python convention of [index, item]. This is a streaming operation: the index counter is maintained lazily as elements flow through the pipeline.

stdin |> en |> e { p "_->[0]: _->[1]" }
1:5 |> en |> e { p "_->[0]: _->[1]" }
@lines |> en |> grep { _->[0] < 10 } |> e { p _->[1] }

# chunk

chunk N, ITERATOR / chk N, ITERATOR — group elements into N-sized arrayrefs as they stream through.

Elements are buffered until N are collected, then the group is emitted as a single arrayref. The final chunk may contain fewer than N elements if the source is not evenly divisible. This is fully streaming: only one chunk is held in memory at a time, making it safe for large or infinite iterators. Use chunk for batching work (e.g., bulk database inserts) or formatting output into rows.

1:9 |> chk 3 |> e { p join ",", @_ }
# 1,2,3  4,5,6  7,8,9
stdin |> chk 100 |> e { bulk_insert(@_) }

# dedup

dedup ITERATOR / dup ITERATOR — drop consecutive duplicate elements from a stream.

Only adjacent duplicates are removed: if the same value appears later after an intervening different value, it is emitted again. Comparison is string-based by default. This is a streaming operation that holds only the previous element in memory, so it works on infinite iterators. For global deduplication across the entire stream, use distinct instead.

1,1,2,2,3,1,1 |> dedup |> e p        # 1 2 3 1
@sorted |> dedup |> e p              # like uniq(1)
stdin |> dedup |> e p                 # collapse repeated lines

# distinct

distinct LIST — remove duplicate elements, preserving first-occurrence order (alias for uniq).

Each element is compared as a string; the first time a value is seen it is emitted, and all subsequent occurrences are silently dropped. When used in a pipeline the deduplication state is maintained across streamed chunks, so distinct works correctly on lazy iterators and generators. This is a stryke built-in backed by a hash set internally, so it runs in O(n) time regardless of list size.

my @u = distinct(3,1,2,1,3)           # (3,1,2)
1,2,2,3,3,3 |> distinct |> e p        # 1 2 3
stdin |> distinct |> e p              # unique lines

# flatten

flatten LIST / fl LIST — recursively flatten nested arrayrefs into a single flat list.

Flatten walks every element: scalars pass through unchanged, arrayrefs are opened and their contents are recursively flattened, so arbitrarily deep nesting is handled in one call. In pipeline mode (|> fl) it streams element-by-element, so you can chain it with map, grep, or take without materializing the entire intermediate list. The fl alias keeps pipeline chains concise.

my @flat = flatten([1,[2,3]],[4])     # (1,2,3,4)
[1,[2,[3,4]]] |> fl |> e p            # 1 2 3 4
@nested |> fl |> grep { _ > 0 } |> e p

# with_index

with_index LIST / wi LIST — pair each element with its 0-based index as [$item, $index].

Each element is wrapped in a two-element arrayref where _->[0] is the original value and _->[1] is its position. This is useful when you need positional information during a map or grep without maintaining a manual counter. Note the order is [item, index], which differs from enumerate which yields [index, item].

qw(a b c) |> wi |> e { p "_->[1]: _->[0]" }
# 0: a  1: b  2: c
@data |> wi |> grep { _->[1] % 2 == 0 } |> e { p _->[0] }

# first_or

first_or DEFAULT, LIST — return the first element of the list, or DEFAULT if the list is empty.

This is a streaming terminal: it pulls exactly one element from the upstream iterator and returns it, or returns the default value if the iterator is exhausted. It never buffers the entire list. This is especially useful at the end of a grep or map pipeline where you need a safe fallback instead of undef when no match is found.

my $v = first_or 0, @maybe_empty
my $x = grep { _ > 99 } @nums |> first_or -1
stdin |> grep /^ERROR/ |> first_or "(none)" |> p

# range

range(START, END [, STEP]) — create a lazy integer iterator from START to END with an optional step.

The range is inclusive on both ends. When START > END and no step is given, stryke automatically counts downward. An explicit STEP controls the increment and must be negative when counting down, or the range will be empty. The iterator is fully lazy: no list is allocated, and elements are generated on demand, making range(1, 1_000_000) as cheap to create as range(1, 5). Combine with |> to feed into streaming pipelines.

range(1, 5) |> e p                    # 1 2 3 4 5
range(5, 1) |> e p                    # 5 4 3 2 1
range(0, 10, 2) |> e p                # 0 2 4 6 8 10
range(10, 0, -2) |> e p               # 10 8 6 4 2 0

# stdin

stdin — return a streaming iterator over lines read from standard input.

Each call to the iterator reads one line from STDIN, strips the trailing newline, and yields it. The iterator terminates at EOF. Because it is lazy, combining stdin with take, grep, or first_or processes only as many lines as needed — the rest of STDIN is left unconsumed. This is the idiomatic stryke way to build Unix-style filters.

stdin |> grep /error/i |> e p
stdin |> take 5 |> e p
stdin |> en |> e { p "_->[0]: _->[1]" }

# nth

nth N, LIST — return the Nth element using 0-based indexing.

When used in a pipeline, nth consumes and discards the first N elements, returns the next one, and stops — so it short-circuits on infinite iterators. On a plain list, it is equivalent to $list[N] but works as a function call for pipeline composition. Returns undef if the list has fewer than N+1 elements.

my $third = nth 2, @data
1:10 |> nth 4 |> p                   # 5
stdin |> nth 0 |> p                   # first line

# map

map BLOCK LIST — evaluates the block for each element of the list, setting _ to the current element, and returns a new list of all the block's return values. This is the eager version: it consumes the entire input list and produces the entire output list before returning. Use map when you need the full result array or when the input is small. For large or infinite sequences, prefer maps (the streaming variant). The block can return zero, one, or multiple values per element, making map useful for both transformation and flattening. Use { |$var| body } to name the block parameter instead of _.

my @sq = map { _ ** 2 } 1:5
@sq |> e p   # 1 4 9 16 25
map { |$n| $n * $n }, 1:5   # named param
my @pairs = map { (_, _ * 10) } 1:3
@pairs |> e p   # 1 10 2 20 3 30

# grep

grep { BLOCK } LIST — filters the list, returning only elements for which the block evaluates to true. The current element is available as _. This is the eager version: it processes the entire list and returns a new list. It is Perl-compatible and works exactly like Perl's builtin grep. For streaming/lazy filtering in |> pipelines, use greps or filter instead. Use { |$var| body } to name the block parameter instead of _.

my @evens = grep { _ % 2 == 0 } 1:10
@evens |> e p   # 2 4 6 8 10
grep { |$x| $x > 3 }, 1:6   # named param
my @long = grep { len > 3 } @words

# sort

sort [BLOCK] LIST — returns a new list sorted in ascending order. Without a block, sort compares elements as strings (lexicographic). Pass a comparator block; the two candidates are _ and _1. Use <=> for numeric and cmp for string comparison. The sort is stable in stryke, meaning equal elements preserve their original relative order. For descending order, reverse the operands in the comparator. Use { |$x, $y| body } to name the two comparator params. Works naturally in |> pipelines.

my @nums = (3, 1, 4, 1, 5)
my @asc = sort { _ <=> _1 } @nums
@asc |> e p   # 1 1 3 4 5
sort { |$x, $y| $y <=> $x }, @nums   # named params
my @desc = sort { _1 <=> _ } @nums
@desc |> e p  # 5 4 3 1 1
@nums |> sort |> e p   # string sort in pipeline

# reverse

reverse LIST — in list context, return the elements in reverse order; in scalar context, reverse the characters of a string.

The dual nature of reverse is context-dependent: reverse @array flips element order, while scalar reverse $string (or just reverse $string in scalar context) reverses character order. In stryke, the string form is Unicode-aware, correctly reversing multi-byte characters rather than individual bytes. In |> pipelines, use the t rev shorthand for a concise streaming string reverse. reverse does not modify the original — it always returns a new list or string.

p reverse "hello"       # olleh
my @r = reverse 1:5   # (5,4,3,2,1)
@r |> e p               # 5 4 3 2 1
"abc" |> t rev |> p     # cba

# reduce

reduce { _ OP _1 } @list — performs a sequential left fold over the list. The first two elements are _ and _1; each iteration's result becomes the next _. Use { |$acc, $val| body } to name the two params. Returns undef for an empty list and the single element for a one-element list. For a fold with an explicit initial value, see fold.

my $fac = reduce { _ * _1 } 1:6
p $fac   # 720
reduce { |$acc, $val| $acc + $val }, 1:10   # 55 (named params)
my $longest = reduce { length(_) > length(_1) ? _ : _1 } @words

# fold

fold { _ OP _1 } INIT, @list — left fold with an explicit initial accumulator value. The initial value is the first _, and each list element is _1. Unlike reduce, fold never returns undef for an empty list — it returns the initial value instead. Use fold when you need a guaranteed starting point for the accumulation.

my $total = fold { _ + _1 } 100, 1:5
p $total   # 115
my $csv = fold { _ . "," . _1 } "", @fields

# reductions

reductions { _ OP _1 } @list — returns the running (cumulative) results of a left fold, also known as a scan or prefix-sum. Each element of the output is the accumulator state after processing the corresponding input element. The output list has the same length as the input.

my @pfx = reductions { _ + _1 } 1:4
@pfx |> e p   # 1 3 6 10
1:5 |> reductions { _ * _1 } |> e p  # 1 2 6 24 120

# all

all { COND } @list — returns true (1) if every element in the list satisfies the predicate, false ("") otherwise. The block receives each element as _ and should return a boolean. Short-circuits on the first failing element, so it never evaluates more than necessary. Works with |> pipelines and accepts bare lists or array variables.

my @nums = 2, 4, 6, 8
p all { _ % 2 == 0 } @nums   # 1
1:100 |> all { _ > 0 } |> p  # 1

# any

any { COND } @list — returns true (1) if at least one element satisfies the predicate, false ("") if none do. The block receives each element as _. Short-circuits on the first match, making it efficient even on large lists. any is a stryke global builtin and can be used in |> pipelines.

my @vals = 1, 3, 5, 8
p any { _ > 7 } @vals   # 1
1:1000 |> any { _ == 42 } |> p  # 1

# none

none { COND } @list — returns true (1) if no element satisfies the predicate, false ("") if any element matches. Logically equivalent to !any { COND } @list but reads more naturally in guard clauses. Short-circuits on the first match. Useful for validation checks where you want to assert the absence of a condition.

my @words = ("cat", "dog", "bird")
p none { /z/ } @words   # 1
p "all non-negative" if none { _ < 0 } @vals

# first

first { COND } @list — returns the first element for which the block returns true, or undef if no element matches. The alias fst is also available. Short-circuits immediately upon finding a match, so only the minimum number of elements are tested. Ideal for searching sorted or unsorted lists when you need a single result.

my $f = first { _ > 10 } 3, 7, 12, 20
p $f   # 12
1:1_000_000 |> first { _ % 9999 == 0 } |> p  # 9999

# min

min @list — returns the numerically smallest value from a list. Compares all elements using numeric (<=>) comparison, so stringy values are coerced to numbers. Returns undef for an empty list. In stryke, min is a global built-in (no import needed) and works directly in |> pipelines.

p min(5, 3, 9, 1)   # 1
my @temps = (72.1, 68.5, 74.3)
@temps |> min |> p  # 68.5

# max

max @list — returns the numerically largest value from a list. Compares all elements using numeric (<=>) comparison. Returns undef for an empty list. Like min, this is a stryke built-in available without imports and works in |> pipelines. Combine with map to extract max values from complex structures.

p max(5, 3, 9, 1)   # 9
1:100 |> map { _ ** 2 } |> max |> p  # 10000

# sum

sum @list returns the numeric sum of all elements. Returns undef for an empty list. sum0 is identical except it returns 0 for an empty list, which avoids the need for a fallback // 0 guard. Both are stryke built-ins that work in |> pipelines. Use sum0 in contexts where an empty input is expected and you need a safe numeric default.

p sum(1:100)    # 5050
p sum0()          # 0
@prices |> map { _->{amount} } |> sum0 |> p

# product

product @list — returns the product of all numeric elements in the list. Returns undef for an empty list. Useful for computing factorials, combinatoric products, and compound multipliers. In stryke this is a built-in that composes naturally with |> pipelines and range.

p product(1:5)   # 120
range(1, 10) |> product |> p  # 3628800

# mean

mean @list — returns the arithmetic mean (average) of a numeric list. Computed as sum / count in a single pass. Returns undef for an empty list. The result is always a floating-point value even if all inputs are integers. Combine with map to compute averages over extracted fields.

p mean(2, 4, 6, 8)   # 5
@students |> map { _->{score} } |> mean |> p

# median

median @list — returns the median value of a numeric list. For odd-length lists, this is the middle element after sorting. For even-length lists, it is the arithmetic mean of the two middle elements. The input list does not need to be pre-sorted. Returns undef for an empty list.

p median(1, 3, 5, 7, 9)   # 5
p median(1, 3, 5, 7)      # 4
1:100 |> median |> p     # 50.5

# mode

mode @list — returns the most frequently occurring value in the list. If there is a tie, the value that appears first in the list wins. Returns undef for an empty list. Works with both numeric and string values — comparison is done by stringification. Useful for finding the dominant category in a dataset.

p mode(1, 2, 2, 3, 3, 3)   # 3
my @logs = qw(INFO WARN INFO ERROR INFO)
p mode(@logs)  # INFO

# stddev

stddev @list (alias std) — returns the population standard deviation of a numeric list. This is the square root of the population variance, measuring how spread out values are from the mean. Uses N (not N-1) in the denominator, so it computes the population statistic rather than the sample statistic. Returns undef for an empty list.

p stddev(2, 4, 4, 4, 5, 5, 7, 9)   # 2
1:10 |> std |> p

# variance

variance @list — returns the population variance of a numeric list, computed as the mean of the squared deviations from the mean. Like stddev, this uses N (not N-1) as the divisor. The variance is stddev ** 2. Returns undef for an empty list. Useful for statistical analysis and as a building block for higher-order stats.

p variance(2, 4, 4, 4, 5, 5, 7, 9)   # 4
my @samples = map { rand(100) } 1:1000
p variance(@samples)

# sample

sample N, @list — returns a random sample of N elements drawn without replacement from the list. The returned elements are in random order. If N exceeds the list length, the entire list is returned (shuffled). Uses a Fisher-Yates partial shuffle internally for efficiency. Each call produces a different result due to random selection.

my @pick = sample 3, 1:100
@pick |> e p   # 3 random values
my @test_cases = sample 10, @all_cases

# shuffle

shuffle @list — returns a new list with all elements in random order using a Fisher-Yates shuffle. The original list is not modified. Every permutation is equally likely. In stryke this is a global built-in; no import is needed. The alias shuf is also available. Commonly used with |> and take to draw random subsets.

my @deck = shuffle 1:52
@deck |> take 5 |> e p   # 5 random cards
my @randomized = shuffle @questions

# uniq

uniq @list — removes duplicate elements from a list, preserving the order of first occurrence. Comparison is done by string equality. The alias uq is also available. This is eager (not streaming) and returns a new list. For streaming deduplication in |> pipelines, use distinct. For type-specific comparison, see uniqnum, uniqstr, and uniqint.

my @u = uniq 1, 2, 2, 3, 1, 3
@u |> e p   # 1 2 3
my @hosts = uniq @all_hosts

# uniqint

uniqint @list — removes duplicate elements comparing values as integers. Each element is truncated to its integer part before comparison, so 1.1 and 1.9 are considered equal (both become 1). The first occurrence is kept. This is useful when you have floating-point data but care only about the integer portion for uniqueness.

my @u = uniqint 1, 1.1, 1.9, 2
@u |> e p   # 1 2
my @distinct_ids = uniqint @raw_ids

# uniqnum

uniqnum @list — removes duplicate elements comparing values as floating-point numbers. Unlike uniq (which compares as strings), uniqnum treats 1.0 and 1.00 as equal because they have the same numeric value. The first occurrence of each numeric value is preserved. Use this when your data contains numbers that may have different string representations.

my @u = uniqnum 1.0, 1.00, 2.5, 2.50
@u |> e p   # 1 2.5
my @prices = uniqnum @all_prices

# uniqstr

uniqstr @list — removes duplicate elements comparing values strictly as strings. This is the same comparison as uniq but makes the intent explicit. Numeric values 1 and 1.0 are considered different because their string representations differ. Use uniqstr when you want to be explicit that string semantics are intended.

my @u = uniqstr "a", "b", "a", "c"
@u |> e p   # a b c
my @tags = uniqstr @all_tags

# zip

zip(\@a, \@b, ...) — combines multiple arrays element-wise into a list of arrayrefs. Each output arrayref contains one element from each input array at the corresponding index. Accepts two or more array references. The alias zp is also available. By default, zip pads shorter arrays with undef (equivalent to zip_longest). For truncating behavior, use zip_shortest.

my @a = 1:3
my @b = ("a","b","c")
zip(\@a, \@b) |> e p   # [1,a] [2,b] [3,c]
my @matrix = zip(\@xs, \@ys, \@zs)

# zip_longest

zip_longest(\@a, \@b, ...) — combines arrays element-wise, padding shorter arrays with undef to match the longest. This is the explicit version of the default zip behavior. Every input array contributes exactly one element per output tuple; missing elements become undef. Useful when you need to process all data from unequal-length sources.

my @a = 1:3
my @b = ("x")
zip_longest(\@a, \@b) |> e p   # [1,x] [2,undef] [3,undef]

# zip_shortest

zip_shortest(\@a, \@b, ...) — combines arrays element-wise, stopping at the shortest input array. No undef padding is produced; the output length equals the minimum input length. Use this when you only want complete tuples and extra trailing elements should be discarded.

my @a = 1:5
my @b = ("x","y")
zip_shortest(\@a, \@b) |> e p   # [1,x] [2,y]
my @paired = zip_shortest(\@keys, \@values)

# chunked

chunked N, @list — splits a list into non-overlapping chunks of N elements each. Each chunk is an arrayref. The final chunk may contain fewer than N elements if the list length is not evenly divisible. The alias chk is also available. In stryke, chunked is eager and returns a list of arrayrefs; for streaming chunk behavior in pipelines, use chunk.

my @ch = chunked 3, 1:7
@ch |> e p   # [1,2,3] [4,5,6] [7]
1:12 |> chunked 4 |> e { p join ",", @_ }

# windowed

windowed N, @list — returns a sliding window of N consecutive elements over the list. Each window is an arrayref. The output contains len - N + 1 windows. Unlike chunked, windows overlap: each successive window advances by one element. The alias win is also available. Useful for computing moving averages, detecting patterns in sequences, or n-gram extraction.

my @w = windowed 3, 1:5
@w |> e p   # [1,2,3] [2,3,4] [3,4,5]
my @deltas = windowed(2, @vals) |> map { _->[1] - _->[0] }

# pairs

pairs @list — takes a flat list and groups consecutive elements into pairs, returning a list of two-element arrayrefs ([$k, $v], ...). The input list must have an even number of elements. Each pair can be accessed via array indexing (_->[0], _->[1]). This is the inverse of unpairs and is commonly used to iterate over hash-like flat lists in a structured way.

my @p = pairs "a", 1, "b", 2
@p |> e { p "_->[0]=_->[1]" }   # a=1 b=2
my @entries = pairs %hash

# unpairs

unpairs @list_of_pairs — flattens a list of two-element arrayrefs back into a flat key-value list. This is the inverse of pairs. Each arrayref [$k, $v] becomes two consecutive elements in the output. Useful for converting structured pair data back into a format suitable for hash assignment or flat list processing.

my @flat = unpairs ["a",1], ["b",2]
@flat |> e p   # a 1 b 2
my %h = unpairs @filtered_pairs

# pairkeys

pairkeys @list — extracts the keys (even-indexed elements) from a flat pairlist. Given a list like ("a", 1, "b", 2, "c", 3), returns ("a", "b", "c"). This is equivalent to map { _->[0] } pairs @list but more concise and efficient. Useful for extracting just the key side of a key-value flat list without constructing intermediate pair objects.

my @k = pairkeys "a", 1, "b", 2, "c", 3
@k |> e p   # a b c
my @config_pairs = (host => "localhost", port => 8080)
my @names = pairkeys @config_pairs

# pairvalues

pairvalues @list — extracts the values (odd-indexed elements) from a flat pairlist. Given ("a", 1, "b", 2), returns (1, 2). This is equivalent to map { _->[1] } pairs @list but more concise. Pair it with pairkeys to split a flat key-value list into separate key and value arrays.

my @v = pairvalues "a", 1, "b", 2
@v |> e p   # 1 2
my @defaults = (timeout => 30, retries => 3)
my @settings = pairvalues @defaults

# pairmap

pairmap BLOCK @list — maps over consecutive pairs in a flat list, passing the key as _ and the value as _1. The block can return any number of elements. This is the pair-aware equivalent of map and is ideal for transforming hash-like flat lists. The result is a flat list of whatever the block returns.

my @out = pairmap { _ . "=" . _1 } "a", 1, "b", 2
@out |> e p   # a=1 b=2
my @cfg_pairs = (host => "x", port => 80)
my @upper = pairmap { uc(_), _1 } @cfg_pairs

# pairgrep

pairgrep { BLOCK } @list — filters consecutive pairs from a flat list, keeping only those where the block returns true. The key is _ and the value is _1. Returns a flat list of the matching key-value pairs. This is the pair-aware equivalent of grep and is useful for filtering hash-like data by both key and value simultaneously.

my @big = pairgrep { _1 > 5 } "a", 3, "b", 9, "c", 1
@big |> e p   # b 9
my @alert_pairs = (info => 1, critical_a => 9, critical_b => 7)
my @important = pairgrep { _ =~ /^critical/ } @alert_pairs

# pairfirst

pairfirst { BLOCK } @list — returns the first pair from a flat list where the block returns true, as a two-element list ($key, $value). The key is _ and the value is _1. Short-circuits on the first match. Returns an empty list if no pair matches. This is the pair-aware equivalent of first.

my @hit = pairfirst { _1 > 5 } "x", 2, "y", 8
p "@hit"   # y 8
my @flags = (info => 1, debug => 7, trace => 0)
my ($k, $v) = pairfirst { _ eq "debug" } @flags

# mesh

mesh(\@a, \@b, ...) — interleaves multiple arrays into a flat list rather than arrayrefs. While zip returns ([1,"a"], [2,"b"]), mesh returns (1, "a", 2, "b"). This makes it ideal for constructing hashes from parallel key and value arrays. The result is a flat list suitable for direct hash assignment.

my @k = ("a","b")
my @v = (1,2)
my %h = mesh(\@k, \@v)
p $h{a}   # 1
my %lookup = mesh(\@ids, \@names)

# mesh_longest

mesh_longest(\@a, \@b, ...) — interleaves arrays into a flat list, padding shorter arrays with undef to match the longest. Like mesh, the output is flat (not arrayrefs). Missing elements become undef in the output sequence. Use this when building a flat interleaved list from arrays of unequal length where you need every element represented.

my @a = 1:3
my @b = ("x")
my @r = mesh_longest(\@a, \@b)
@r |> e p   # 1 x 2 undef 3 undef

# mesh_shortest

mesh_shortest(\@a, \@b, ...) — interleaves arrays into a flat list, stopping at the shortest input array. No undef padding is produced; trailing elements from longer arrays are silently dropped. Use this when you only want complete interleaved groups and partial data should be discarded.

my @a = 1:3
my @b = ("x","y")
my @r = mesh_shortest(\@a, \@b)
@r |> e p   # 1 x 2 y

# partition

partition — operation partition. Alias for take_while. Category: *functional / iterator*.

p partition $x

# frequencies

frequencies (aliases freq, frq) counts how many times each distinct element appears in a list and returns a hashref mapping each value to its count. This is the stryke equivalent of a histogram or counter — useful for analyzing log files, counting word occurrences, tallying categorical data, or finding duplicates. The input list is flattened, so you can pass arrays directly. The returned hashref can be fed into dd for inspection or to_json for serialization.

my @words = qw(apple banana apple cherry banana apple)
my $counts = freq @words
p $counts   # {apple => 3, banana => 2, cherry => 1}
rl("access.log") |> map { /^(\S+)/ && $1 } |> freq |> dd
my @rolls = map { 1 + int(rand 6) } 1:1000
frq(@rolls) |> to_json |> p

# tally

tally counts how many times each distinct element appears in a list and returns a hash ref mapping element → count. This is the same as Ruby's Enumerable#tally or Python's Counter. Similar to frequencies but follows the Ruby naming convention.

my $t = tally("a", "b", "a", "c", "a", "b")
p $t->{a}   # 3
p $t->{b}   # 2
qw(red blue red green blue red) |> tally |> dd

# interleave

interleave (alias il) merges two or more arrays by alternating their elements: first element of each array, then second element of each, and so on. If the arrays have different lengths, shorter arrays contribute undef for their missing positions. This is useful for building key-value pair lists from separate key and value arrays, creating round-robin schedules, or weaving parallel data streams together.

my @keys = qw(name age city)
my @vals = ("Alice", 30, "NYC")
my @pairs = il \@keys, \@vals
p @pairs   # name, Alice, age, 30, city, NYC
my %h = il \@keys, \@vals
p $h{name} # Alice
my @rgb = il [255,0,0], [0,255,0], [0,0,255]

# pluck

pluck KEY, LIST_OF_HASHREFS — extract a single key from each hashref in the list.

For each element, pluck dereferences it as a hashref and returns the value at the given key. Elements where the key is missing yield undef. This is a streaming operation: in a pipeline, each hashref is processed and the extracted value is emitted immediately. It is the stryke equivalent of map { _->{KEY} } but more readable and optimized internally.

@users |> pluck "name" |> e p
my @ids = pluck "id", @records
@rows |> pluck "email" |> distinct |> e p

# grep_v

grep_v PATTERN, LIST — inverse grep: reject elements that match the pattern, keep the rest.

This is the complement of grep — any element where the pattern matches is dropped, and non-matching elements pass through. It accepts a regex, a string, or a code block as the pattern. In streaming mode, each element is tested and either forwarded or discarded without buffering. This is a stryke built-in that avoids the awkward grep { !/pattern/ } double-negation.

@words |> grep_v /^ #/ |> e p          # drop comments
my @clean = grep_v qr/tmp/, @files
stdin |> grep_v /^\s*$/ |> e p        # drop blank lines

# select_keys

select_keys — operation select keys. Category: *pipeline / string helpers*.

p select_keys $x

# clamp

clamp (alias clp) constrains each value in a list to lie within a specified minimum and maximum range. Values below the minimum are raised to it; values above the maximum are lowered to it; values already in range pass through unchanged. This is essential for sanitizing user input, bounding computed values before display, or enforcing physical constraints in simulations. When given a single scalar, it returns a single clamped value.

my @scores = (105, -3, 42, 99, 200)
my @clamped = clp 0, 100, @scores
p @clamped   # 100, 0, 42, 99, 100
my $val = clp 0, 255, $input   # bound to byte range
my @pct = map { clp 0.0, 1.0, _ } @raw_ratios

# normalize

normalize (alias nrm) rescales a list of numeric values so that the minimum maps to 0 and the maximum maps to 1, using min-max normalization. This is a standard preprocessing step for machine learning features, data visualization (mapping values to color gradients or bar heights), and statistical analysis. If all values are identical, the result is a list of zeros to avoid division by zero. The output preserves the relative ordering of the input.

my @temps = (32, 68, 100, 212)
my @normed = nrm @temps
p @normed   # 0, 0.2, 0.377..., 1
my @pixels = nrm @raw_intensities
@pixels |> map { int(_ * 255) } |> e p  # scale to 0-255

# compose

compose (alias comp) creates a right-to-left function composition. Given compose(\&f, \&g), calling the result with x computes f(g(x)). Chain any number of functions — they apply from right to left (last argument first). This is the standard mathematical function composition found in Haskell, Clojure, and Ramda. The returned code ref can be stored, passed around, or used in pipelines.

my $double = fn { _0 * 2 }
my $inc    = fn { _0 + 1 }
my $f = compose($inc, $double)
p $f->(5)   # 11  (double 5 → 10, inc 10 → 11)

my $pipeline = compose(
    fn { join ",", @{_0} },
    fn { [sort @{_0}] },
    fn { [grep { _ > 2 } @{_0}] },
)
p $pipeline->([3,1,4,1,5])  # 3,4,5

# partial

partial returns a partially applied function — the bound arguments are prepended to any arguments supplied at call time. partial(\&f, @bound)->(x) is equivalent to f(@bound, x). This is the standard partial application from functional programming, useful for creating specialized versions of general functions without closures.

my $add = fn { _0 + _1 }
my $add5 = partial($add, 5)
p $add5->(3)   # 8

my $log = fn { p "[#{_0}] #{_1}" }
my $warn_log = partial($log, "WARN")
$warn_log->("disk full")   # [WARN] disk full

# curry

curry auto-curries a function with a given arity. The curried function accumulates arguments across calls and invokes the original only when enough have been collected. curry(\&f, N)->(a)->(b) calls f(a, b) when N=2. If all arguments are supplied at once, it calls immediately.

my $add = curry(fn { _0 + _1 }, 2)
my $add5 = $add->(5)
p $add5->(3)       # 8
p $add->(10, 20)   # 30  (enough args — calls immediately)

# memoize

memoize (alias memo) wraps a function so that repeated calls with the same arguments return a cached result instead of re-executing the function. Arguments are stringified and joined as the cache key. This is essential for expensive pure functions like recursive algorithms, API lookups with stable results, or any computation where the same inputs always produce the same output.

my $fib = memoize(fn {
    my $n = _0
    $n < 2 ? $n : $fib->($n-1) + $fib->($n-2)
})
p $fib->(30)   # instant (without memoize: ~1B calls)

my $fetch_user = memo(fn { fetch_json("https://api/users/#{_0}") })
$fetch_user->(42)   # hits API
$fetch_user->(42)   # returns cached

# once

once wraps a function so it is called at most once. The first invocation executes the function and caches the result; all subsequent calls return the cached value without re-executing. This is ideal for lazy initialization, one-time setup, or singleton patterns.

my $init = once(fn { p "initializing..."
    42 })
p $init->()   # prints "initializing..." → 42
p $init->()   # 42 (no print — cached)
p $init->()   # 42 (still cached)

# constantly

constantly (alias const) returns a function that ignores all arguments and always returns the given value. Useful as a default callback, a stub in higher-order function pipelines, or anywhere a function is required but a fixed value suffices.

my $zero = constantly(0)
p $zero->("anything")   # 0
my @defaults = map { constantly(0)->() } 1:5   # [0,0,0,0,0]

# complement

complement (alias compl) wraps a predicate function and returns a new function that negates its boolean result. complement(\&even?)->(3) returns true. This is the functional equivalent of !f(x) without creating a closure.

my $even = fn { _0 % 2 == 0 }
my $odd = complement($even)
p $odd->(3)   # 1
p $odd->(4)   # 0
1:10 |> grep { complement($even)->(_) } |> e p  # 1 3 5 7 9

# juxt

juxt (juxtapose) takes multiple functions and returns a new function that calls each one with the same arguments and collects the results into an array. This is useful for computing multiple derived values from the same input in a single pass.

my $stats = juxt(fn { min @_ }, fn { max @_ }, fn { avg @_ })
my @r = $stats->(3, 1, 4, 1, 5)
p "@r"   # 1 5 2.8

# fnil

fnil wraps a function so that any undef arguments are replaced with the given defaults before the function is called. This eliminates repetitive // $default patterns inside function bodies.

my $greet = fnil(fn { "Hello, #{_0}!" }, "World")
p $greet->(undef)    # Hello, World!
p $greet->("Alice")  # Hello, Alice!

# deep_clone

deep_clone (alias dclone) performs a recursive deep copy of a nested data structure. Array refs, hash refs, and scalar refs are cloned recursively so that the result shares no references with the original. Modifications to the clone never affect the source. This is the stryke equivalent of JavaScript's structuredClone or Perl's Storable::dclone.

my $orig = {users => [{name => "Alice"}], meta => {v => 1}}
my $copy = deep_clone($orig)
$copy->{users}[0]{name} = "Bob"
p $orig->{users}[0]{name}   # Alice (unchanged)

# deep_merge

deep_merge (alias dmerge) recursively merges two hash references. When both sides have a hash ref for the same key, they are merged recursively; otherwise the right-hand value wins. This is the standard deep merge from Lodash, Ruby's deep_merge, and config-file overlay patterns. Returns a new hash ref — neither input is modified.

my $defaults = {db => {host => "localhost", port => 5432}, debug => 0}
my $overrides = {db => {port => 3306}, debug => 1}
my $cfg = deep_merge($defaults, $overrides)
p $cfg->{db}{host}   # localhost (from defaults)
p $cfg->{db}{port}   # 3306 (overridden)
p $cfg->{debug}      # 1 (overridden)

# deep_equal

deep_equal (alias deq) performs structural equality comparison of two values, recursively descending into array refs, hash refs, and scalar refs. Returns 1 if the structures are identical, 0 otherwise. This is the stryke equivalent of Node's assert.deepStrictEqual, Lodash isEqual, or Python's == on nested dicts/lists.

p deep_equal([1, {a => 2}], [1, {a => 2}])   # 1
p deep_equal([1, {a => 2}], [1, {a => 3}])   # 0
p deq({x => [1,2]}, {x => [1,2]})            # 1

# ->

Arrow operator — method invocation on objects/classes and dereference of refs. The single most-used operator in Perl OOP and any code touching references.

# Method call (object or class):
my $p = Point->new(x => 1, y => 2)
p $p->x                                    # 1
p Math::Utils->compute(@args)

# Hash-ref dereference:
my $cfg = { host => "localhost", port => 5432 }
p $cfg->{host}
$cfg->{port} = 6543

# Array-ref dereference:
my $rows = [[1,2,3], [4,5,6]]
p $rows->[1][2]                            # 6 (chained — implicit ->)
my $val = $rows->[0]->[2]                  # explicit form: 3

# Code-ref invocation:
my $f = fn ($x) { $x * 2 }
p $f->(21)                                 # 42

# Postfix-deref (modern):
my @copy = $rows->@*                       # all elements
my %env  = %ENV->%*                        # entire hash via slice

Chained arrow elision — between subscripts ([..], {..}), -> is optional: $rows->[1][2] ≡ $rows->[1]->[2]. The first arrow after a scalar variable is *required*; intermediate arrows can be omitted for chained subscripting only.

See also: ->> / ~>> (thread-last macros — distinct operator), bless, class, new, ref.

# new

new — the default constructor automatically provided for every class and struct. Called as ClassName->new(field1 => v1, field2 => v2, ...). Returns a blessed object whose attribute storage is initialized from the named arguments. If the class defines a BUILD method, new runs it *after* attribute initialization but *before* returning, so BUILD can validate, derive fields, or attach external resources. A class never overrides new itself in stryke — to customize construction, define BUILD (post-init hook) instead.

Implementation: vm_helper.rs:10686 — when ->new is called and no user-defined new exists, the runtime dispatches to builtin_new which allocates the object, populates fields from the arglist, then calls BUILD via the C3 MRO if present.

class Point {
    has 'x' => (is => 'ro', default => 0)
    has 'y' => (is => 'ro', default => 0)
}
my $p = Point->new(x => 1.5, y => 2.0)
p $p->x          # 1.5

class Connection {
    has 'host' => (is => 'ro', required => 1)
    has 'port' => (is => 'ro', default => 5432)
    fn BUILD($self, $args) {
        die "host required" unless $self->host
    }
}
my $c = Connection->new(host => "db.example.com")

See also: BUILD (post-init hook), DESTROY (destructor), class, struct, bless, @ISA.

# $

Scalar sigil. $name accesses a scalar variable. $ref holds references. $h{key} accesses one hash value; $arr[idx] accesses one array element (sigil reflects the *value being accessed*, not the container). For postfix-deref: $ref->$* (in stryke contexts that accept it).

my $x = 42                    # scalar declaration
my @arr = (1, 2, 3)
p $arr[0]                     # 1 — scalar context on @arr
my %h = (k => "v")
p $h{k}                       # one value
my $ref = \@arr               # reference, scalar holds it

See also: @ (array sigil), % (hash sigil), \ (reference), ->.

# @

Array sigil. @name accesses an entire array. @h{@keys} is a hash slice (multiple values by key list). @a[@idx] is an array slice. @_ is the implicit sub argument array. Stringified in double quotes by joining elements with $" (space by default).

my @nums = (1, 2, 3)
p scalar @nums            # 3 — length in scalar context
p "@nums"                  # 1 2 3 — joined with $"
my @slice = @arr[1..3]    # array slice
my @vals  = @h{qw(a b c)}  # hash slice

See also: $ (scalar sigil), % (hash sigil), @_, $", postfix-deref ->@*.

# %

Hash sigil / modulo operator — same character, two meanings disambiguated by context.

As sigil (preceding a name): %h accesses the whole hash. %ENV is the env hash, %h = (k1 => v1, k2 => v2) declares one, keys %h / values %h / each %h iterate. The sigil reflects the *whole hash*; one value is $h{k} (scalar).

As operator (between expressions): $x % $y is integer modulo (remainder); result takes the sign of the right operand.

my %cfg = (host => "localhost", port => 5432)
p keys %cfg               # hash iteration
p 10 % 3                  # 1 — modulo
p -7 % 3                  # 2 — Perl semantics: sign matches RHS

See also: $ (scalar), @ (array), %=, %ENV, %SIG.

# +

Addition / numeric coercion. $x + $y adds two numbers. Operands are coerced to numeric context — strings parse as \d+(\.\d+)? until a non-numeric character, so "5 apples" + 3 == 8. Use . (dot) for string concatenation; using + on intended-strings is a common bug since the strings parse to 0 silently under no warnings. As a unary prefix, +EXPR forces numeric context without changing value.

p 2 + 3                # 5
p "10x" + 5            # 15 — leading digits parse
p "x10" + 5            # 5  — leading non-digit → 0
my $sum = sum(1:100)   # 5050

See also: -, *, /, += (compound assign), . (string concat).

# -

Subtraction / unary minus / file-test operator. Binary: $x - $y subtracts numbers (same coercion rules as +). Unary: -EXPR negates. Special: -X FILE where X is a single letter is a file-test operator (-e exists, -f regular file, -d directory, -r readable, -w writable, -x executable, -s size in bytes, -M age in days, etc.).

p 10 - 3              # 7
p -5 * 2               # -10
if (-e $path) { p "exists" }
if (-f $path && -r _) { p "readable file" }   # _ reuses last stat

See also: +, -=, file-test reference.

# *

Multiplication / glob deref. Binary: $x * $y multiplies numbers. In expression context (*name), references the typeglob for that name — rarely used directly; assigning *alias = \&func installs an alias for the sub.

p 6 * 7              # 42
my $area = $w * $h
*shortcut = \&long_function_name   # sub alias

See also: *=, ** (exponent), x (string/list repeat — NOT multiplication).

# /

Division / regex delimiter. Binary: $x / $y divides as floats. Stryke uses true division — 5 / 2 == 2.5, not 2. Use int($x / $y) or intdiv($x, $y) for integer division. In expression context, /PATTERN/ opens a regex — context-dependent: after an operator or at statement start, / parses as regex; after a variable or value, it's division.

p 10 / 4               # 2.5
p int(10 / 4)          # 2
if ($s =~ /^\d+$/) { p "all digits" }

See also: *, % (modulo), /=, regex syntax, intdiv.

# **

Exponentiation. $x ** $y raises $x to the $y-th power. Floating-point throughout — 2 ** 10 == 1024, 2 ** 0.5 == 1.414.... Right-associative: 2 ** 3 ** 2 == 2 ** 9 == 512. Negative bases with fractional exponents return NaN.

p 2 ** 10              # 1024
p 2 ** 0.5             # 1.4142135623731
p 2 ** 3 ** 2          # 512 (right-assoc)
my $sq = $r ** 2

See also: **=, sqrt, exp, log.

# ++

Increment. Postfix $x++ returns the value and *then* increments; prefix ++$x increments first and returns the new value. Works on integers, floats, and magic strings ("aa"++ == "ab", "az"++ == "ba", "Az"++ == "Ba"). String increment follows Perl's letter-roll rules — preserves case, rolls letters with carry into the next position.

my $n = 5
p $n++                  # 5  (post: returns old)
p $n                    # 6
p ++$n                  # 7  (pre: returns new)

my $s = "Az"
$s++; p $s              # Ba — magic string increment

See also: --, atomic ++ on mysync shared scalars (always atomic).

# --

Decrement. Postfix $x-- returns the value and *then* decrements; prefix --$x decrements first. Numeric-only — there is no magic-string *decrement* in Perl. On non-numeric strings, -- coerces to 0 first then decrements.

my $n = 5
p $n--                  # 5
p $n                    # 4
p --$n                  # 3

See also: ++, atomic -- on mysync shared scalars.

# .

String concatenation. $x . $y glues two strings together. Both operands are coerced to string context. For multi-arg joins prefer join "", @parts (faster, less typing); for building large strings prefer interpolation or sprintf. The . operator does not insert separators — "hello" . "world" eq "helloworld".

my $name = "world"
p "hello " . $name . "!"        # hello world!
my $full = $first . " " . $last
my $line = sprintf "%-20s %d", $name, $count   # often clearer

See also: .= (append assign), x (repeat), join, sprintf, interpolation.

# x

Repeat operator. STR x N repeats a string N times; (LIST) x N repeats a list. The context of the LHS decides: scalar LHS → string repeat; list LHS (must be in parens) → list repeat. N is truncated to integer; negative or zero N produces empty.

p "=" x 20                        # ====================
p "ab" x 3                        # ababab
my @z = (0) x 10                  # ten zeros
my @grid = ([0,0,0]) x 5           # five distinct rows (each is a new arrayref via shallow copy)

See also: . (concat), x= (compound), repeat.

# ==

Numeric equality. Coerces both operands to numbers and compares. Use eq for strings — "10" == "10.0" is true, but "10" eq "10.0" is false. Float comparison with == is dangerous due to rounding; for tolerances use abs($x - $y) < $epsilon.

p 5 == 5.0                # 1
p "10" == 10              # 1 (numeric coercion)
p "foo" == "bar"          # 1 (both → 0)  — common bug, use eq!
if ($n == 0) { ... }

See also: !=, <=>, eq (string equality), near_eq builtin for float tolerance.

# !=

Numeric inequality. Inverse of ==. Use ne for strings.

p 5 != 6              # 1
while ($i != $target) { ... }

See also: ==, ne, <=>.

# <

Numeric less-than. Coerces to numbers. Use lt for strings.

p 3 < 5                # 1
if ($age < 18) { ... }
my @small = grep { _ < 10 } @nums

Stryke supports chained comparisons Raku-style: 1 < $x < 10 ≡ (1 < $x) && ($x < 10). See chained_comparison.

See also: >, <=, <=>, lt.

# >

Numeric greater-than. Coerces to numbers. Use gt for strings.

p 7 > 5               # 1
my @big = grep { _ > 100 } @vals

Also the redirect operator in open (open my $fh, '>', $path) and the diamond closer (<$fh>).

See also: <, >=, <=>, gt, chained_comparison.

# <=

Numeric less-than-or-equal. Use le for strings. Participates in chained comparisons: 0 <= $i < @arr.

if (0 <= $i < scalar @arr) { p $arr[$i] }

See also: <, >=, <=>, le, chained_comparison.

# >=

Numeric greater-than-or-equal. Use ge for strings.

return if $count >= $max

See also: >, <=, <=>, ge, chained_comparison.

# <=>

Spaceship operator — numeric three-way compare. Returns -1, 0, or 1. The standard sort comparator for numeric sort.

my @sorted = sort { $a <=> $b } @nums        # ascending
my @desc   = sort { $b <=> $a } @nums         # descending
p 5 <=> 10                                     # -1
p 10 <=> 10                                    # 0
p 15 <=> 10                                    # 1

See also: cmp (string version), sort, $a, $b.

# eq

String equality. Compares operands as strings. "10" eq "10.0" is false. The string-context counterpart of ==.

if ($cmd eq "start") { ... }
p "abc" eq "abc"                # 1
p "abc" eq "ABC"                # "" (case matters)

See also: ne, cmp, == (numeric), lc/uc for case-insensitive compare.

# ne

String inequality. Inverse of eq.

next if $line ne ""

See also: eq, cmp, != (numeric).

# lt

String less-than — lexicographic comparison. Use < for numeric.

p "apple" lt "banana"           # 1
my @sorted = sort { $a lt $b ? -1 : 1 } @words

See also: gt, le, cmp, < (numeric), chained_comparison.

# le

String less-than-or-equal — lexicographic. Use <= for numeric. Participates in chained comparisons.

See also: lt, ge, cmp.

# gt

String greater-than — lexicographic.

p "banana" gt "apple"           # 1

See also: lt, ge, cmp, > (numeric).

# ge

String greater-than-or-equal — lexicographic. Use >= for numeric.

See also: gt, le, cmp.

# cmp

String three-way compare — returns -1, 0, or 1. The standard sort comparator for string sort.

my @sorted = sort { $a cmp $b } @words      # case-sensitive
my @ci     = sort { lc($a) cmp lc($b) } @words   # case-insensitive
p "alice" cmp "bob"            # -1

See also: <=> (numeric three-way), eq, lt, gt, sort.

# &&

Logical AND (high-precedence). Short-circuit: returns the first falsy operand, or the last operand if all truthy. Stryke (like Perl) doesn't return boolean — it returns the actual value, which makes idioms like $default = $val && transform($val) work.

if ($x > 0 && $x < 100) { ... }
my $first = $x && $y && $c       # first truthy or last falsy

Lower-precedence variant and binds looser than = so use it for control flow: open $fh, $f and read_loop(). See also: ||, //, and, !.

# ||

Logical OR (high-precedence). Short-circuit: returns the first truthy operand, or the last operand if all falsy. The classic Perl default idiom: my $x = $arg || "default" — but watch out: 0, "", "0", and undef are all falsy, so || falls through for legitimate zero values. Use // (defined-or) when only undef should trigger the fallback.

my $name = $user || "guest"
my $val  = $count // 0          # better: only undef triggers fallback
open $fh, $f or die $!           # `or` is the low-precedence form

See also: &&, //, or, defined.

# //

Defined-or operator. Returns the LHS if it is defined (even if 0 or ""), else the RHS. Distinct from || which treats all falsy values as "use the fallback". Use // whenever you have a numeric default or want to distinguish absent values from explicit zero.

my $count = $opts{count} // 10        # 10 only if missing — 0 is allowed
my $tag = $row->{label} // "untagged"
return $cache{$key} //= compute($key)  # //= : assign only if undef

See also: ||, defined, //=.

# !

Logical NOT (high-precedence). Returns 1 (true) if the operand is falsy, "" (false) if truthy. Lower-precedence variant not reads English-y; prefer ! in expressions, not in conditions.

if (!$ok) { die "failed" }
return unless not @items   # avoid double-negative — prefer `unless @items`
my $inverse = !!$truthy    # !! coerces to canonical 1 / ""

See also: not, unless, &&, ||.

# and

Low-precedence logical AND. Same short-circuit behaviour as && but binds looser than =, ,, and most other operators. Use for control-flow expressions where you'd otherwise need parens: $ok = read_file($path) and parse(...) — but note this assigns to $ok ONLY the return of read_file (because = binds tighter than and). For value-binding use &&.

open $fh, '<', $f and read_loop($fh)   # control flow

See also: &&, or, not.

# or

Low-precedence logical OR. Same short-circuit behaviour as || but binds looser than =. The canonical idiom for open ... or die: open my $fh, $path or die "open: $!". The whole open expression is evaluated, then or die runs only if open returned false.

open my $fh, '<', $f or die "open: $!"
my $val = read_line() or last           # WRONG: assigns the read, not the fallback
my $val = read_line() || last           # WRONG too — falsy values fall through
# Use defined-or for value defaults:
my $val = read_line() // last

See also: ||, //, and.

# not

Low-precedence logical negation — returns true if the expression is false, and false if it is true. Functionally identical to ! but binds looser than almost everything, so not $x == $y is not($x == $y) rather than (!$x) == $y. Useful for readable boolean conditions.

if (not defined $val) {
    p "val is undef"
}
my @missing = grep { not -e _ } @files
@missing |> e p
p not 0    # 1
p not 1    # (empty string)

# xor

Low-precedence logical XOR. Returns true exactly when one operand is truthy and the other is falsy. No short-circuit (both sides always evaluated). Rarely used; if you find yourself wanting xor consider ($x ? 1 : 0) != ($y ? 1 : 0) for clarity.

if ($admin xor $guest) { p "exactly one role" }

See also: &&, ||, ^ (bitwise xor).

# =~

Regex bind — applies the right-side regex/transliteration/substitution to the left-side scalar. Returns success/match data in scalar context, captured groups in list context. Without =~, regex ops default to operating on $_.

if ($line =~ /^\s*#/) { ... }                    # match
my ($host) = $url =~ m{^https?://([^/]+)}        # extract
$text =~ s/foo/bar/g                              # substitute
$str =~ tr/a-z/A-Z/                                # transliterate

See also: !~, m//, s///, tr///, named captures ((?<name>...), %+).

# !~

Negated regex bind. True if the regex does NOT match.

next if $line !~ /^\s*\w/      # skip lines that don't start with a word

See also: =~, m//.

# ..

Range operator. In list context, generates an inclusive integer or magic-string sequence: 1..5 == (1,2,3,4,5). In scalar/boolean context (rare — only in while/if), acts as a flip-flop state machine.

for (1..10) { p _ }
my @letters = ('a'..'z')        # magic string range
my @rev = reverse 1..100

Stryke convention: prefer 1:5 (colon-range, fully equivalent) since it doesn't visually clash with method/property access chains.

See also: ... (three-dot range), : colon range, flip-flop in while.

# ...

Exclusive range / yada-yada. As an operator: 1...5 is the *exclusive* range (does not include the endpoint in some contexts) and the *flip-flop* operator with slightly different reset semantics than ... As a statement: ... alone (the "yada-yada") is a placeholder that compiles fine but dies at runtime — useful for sketching APIs.

fn not_yet_implemented { ... }       # yada-yada — dies if called

See also: .., yada-yada placeholder.

# =>

Fat comma — variant of , that auto-quotes the left operand if it looks like a bareword identifier. The canonical syntax for hash entries and named arguments since it self-documents which side is the key.

my %cfg = (
    host   => "localhost",     # "host" auto-quoted
    port   => 5432,
    debug  => 1,
)
open my $fh, '<', $path or die
Class->new(name => "alice", age => 30)

With strict syntax, , and => are semantically equivalent EXCEPT for the auto-quoting. 1 => 2 is the same as 1 , 2; the magic only fires on bareword LHS.

See also: ,, hash declaration, named parameters.

# ,

Comma operator / list separator. In list context, separates list elements. In scalar context (right-to-left), evaluates each expression for side effects and returns the rightmost (like C). The fat-comma => is a variant that auto-quotes bareword LHS.

my @x = (1, 2, 3)
my %h = (a => 1, b => 2)
for (my $i = 0, my $j = 10; $i < 5; $i++, $j--) { ... }   # scalar context

See also: =>, list operators (push, unshift, …).

# ?:

Ternary conditional — COND ? IF_TRUE : IF_FALSE. Right-associative for chaining. Returns one of the two branches as an expression value, unlike if/else which is a statement. Stryke also accepts the if/else block form as an expression: my $x = do { if (cond) { 1 } else { 2 } }.

my $sign = $n > 0 ? "+" : $n < 0 ? "-" : "0"
p $count == 1 ? "$count item" : "$count items"

Binds looser than most operators; use parens around complex conditions for readability. See also: if/else, match.

# \

Reference operator — takes a reference to a variable, sub, or value. \$scalar, \@array, \%hash, \&sub, \(...). References are scalars; deref with $$ref / @$ref / %$ref / &$ref / $ref->[i] / $ref->{k} / $ref->(...).

my @nums = (1, 2, 3)
my $aref = \@nums
p $$aref[0]                  # 1 (sigil-deref)
p $aref->[0]                  # 1 (arrow-deref — preferred)
p join ",", @$aref            # 1,2,3

my $code = \&my_function
$code->(42)

Also \(LIST) returns a list of references — \(@a, @b) gives one ref per element, not a single ref to the list.

See also: ->, ref, deref syntax, bless.

# &

Bitwise AND (and prototype/sub-deref). On numbers, $x & $y computes the bitwise AND. As a sigil prefix &name calls a sub (in non-bareword contexts) or takes a coderef. With \ makes a coderef: \&sub.

p 0b1100 & 0b1010            # 8 (0b1000)
my $mask = $flags & 0xFF
my $code = \&my_sub          # coderef

See also: |, ^, ~, &&, \& (coderef).

# |

Bitwise OR. $x | $y ORs the bits. Also a regex alternation inside /.../. As a stream operator || is logical OR, |> is pipe-forward.

p 0b1100 | 0b1010           # 14 (0b1110)
my $flags = OPEN_READ | OPEN_NONBLOCK

See also: &, ^, ~, ||, |>, regex alternation.

# ^

Bitwise XOR. $x ^ $y XORs the bits.

p 0b1100 ^ 0b1010           # 6 (0b0110)
my $toggled = $bits ^ $mask

See also: &, |, ~, xor (logical).

# ~

Bitwise NOT (unary). Flips every bit; works on integers. Also the prefix of stryke thread macros (~>, ~p>, ~d>, etc.) — those are distinct multi-char operators, not ~ followed by something.

p ~0                        # -1 (all bits set on signed int)
p ~0xFF                     # …higher bits set
my $inverted = ~$mask & 0xFFFF

See also: &, |, ^, ! (logical NOT), ~> / ~>> / ~p> (distinct ops).

# <<

Left bit-shift / heredoc. As $x << $y, shifts bits left by $y positions. As <<TAG, opens a heredoc (multi-line string literal terminated by TAG at start of line).

p 1 << 10                    # 1024
my $kb = $bytes << 10
my $sql = <<END
    SELECT *
    FROM users
END

See also: >>, <<=, heredoc syntax.

# >>

Right bit-shift / file redirect. As $x >> $y, shifts bits right by $y positions. As a mode in open, >> opens for append.

p 1024 >> 2                  # 256
my $exit_code = $? >> 8       # extract exit code from $?
open my $fh, '>>', 'log.txt' or die

See also: <<, >>=, open modes.

# =

Assignment. Returns the assigned value (so chained $x = $y = 5 works). Context matters: my @a = $scalar copies the scalar's value into a one-element list; my @a = @b does list copy; my $s = @a gives the array's length in scalar context. The single most-used operator after ;.

my $x = 42
my ($x, $y, $c) = (1, 2, 3)        # list-destructure
my ($first, @rest) = split /,/
($x, $y) = ($y, $x)                  # swap
my $len = @items                     # scalar context — count

See also: +=, -=, .=, //=, ||=, &&=, my, our, local, state.

# +=

Add-assign. $x += $y ≡ $x = $x + $y. Atomic on mysync shared scalars.

my $total = 0
$total += $_ for @nums
mysync $sum = 0; fan 10000 { $sum += 1 }   # atomic — always 10000

See also: +, -=, *=, etc.

# -=

Subtract-assign. $x -= $y ≡ $x = $x - $y. Atomic on mysync scalars.

See also: -, +=.

# *=

Multiply-assign. $x *= $y ≡ $x = $x * $y.

See also: *, **=.

# /=

Divide-assign. $x /= $y ≡ $x = $x / $y.

See also: /.

# **=

Power-assign. $x **= $y ≡ $x = $x ** $y.

See also: **.

# .=

Append-assign (string concat). $s .= $more ≡ $s = $s . $more but more efficient for large-string accumulators (single buffer growth, not realloc per concat). Atomic on mysync scalars.

my $buf = ""
$buf .= $line for @lines
mysync $log = ""; fan 100 { $log .= "event\n" }   # atomic

See also: ., +=.

# x=

Repeat-assign (string). $s x= 3 ≡ $s = $s x 3.

my $bar = "="; $bar x= 40        # forty equals signs

See also: x.

# ||=

Or-assign. $x ||= $default ≡ $x = $x || $default — assigns the default only if $x is falsy. Watch out for legitimate falsy values like 0 and ""; prefer //= for those.

$opts{verbose} ||= 0
$cache{$key} ||= compute($key)        # but: returns wrong thing if 0 is valid

See also: ||, //=.

# //=

Defined-or assign. $x //= $default ≡ $x = $x // $default — assigns the default only if $x is undef. The right tool for memoization/cache-fill patterns.

$cache{$key} //= expensive_compute($key)
$count{$word} //= 0; $count{$word}++

See also: //, ||=.

# &&=

And-assign. $x &&= $val ≡ $x = $x && $val — assigns $val only if $x is truthy. Rare.

See also: &&, ||=.

# |=

Bitwise OR-assign. $x |= 0x80 sets a bit. Atomic on mysync scalars.

See also: |.

# &=

Bitwise AND-assign. $x &= 0xFF masks to low byte.

See also: &.

# ^=

Bitwise XOR-assign. $x ^= $bit toggles bits.

See also: ^.

# <<=

Left-shift assign. $x <<= 3 ≡ multiply by 8.

See also: <<.

# >>=

Right-shift assign. $x >>= 3 ≡ integer-divide by 8.

See also: >>.

# fn

Define a named or anonymous function with optional typed parameters and default values. Named functions are installed into the current package; anonymous functions (closures) capture their enclosing lexical scope. Functions are first-class values — assign them to scalars, store in arrays, pass as callbacks. The last expression evaluated is the implicit return value unless an explicit return is used.

fn dbl($x) { $x * 2 }
my $f = fn { _ * 2 }
my $add = fn ($x: Int, $y: Int) { $x + $y }

# Default parameter values:
fn greet($name = "world") { p "hello $name" }
greet()           # hello world
greet("Alice")    # hello Alice

fn range_check($x, $min = 0, $max = 100) { $min <= $x <= $max }
fn with_list(@items = (1, 2, 3)) { join "-", @items }
fn with_hash(%opts = (debug => 0)) { $opts{debug} }

Default values are evaluated at call time if the argument is not provided.

# struct

struct declares a named record type with typed fields, giving stryke lightweight struct semantics similar to Rust structs or Python dataclasses. Structs support multiple construction syntaxes, default values, field mutation, user-defined methods, functional updates, and structural equality.

Declaration:

struct Point { x => Float, y => Float }           # typed fields
struct Point { x => Float = 0.0, y => Float = 0.0 } # with defaults
struct Pair { key, value }                        # untyped (Any)

Construction:

my $p = Point(x => 1.5, y => 2.0)  # function-call with named args
my $p = Point(1.5, 2.0)            # positional (declaration order)
my $p = Point->new(x => 1.5, y => 2.0) # traditional OO style
my $p = Point()                    # uses defaults if defined

Field access (getter/setter):

p $p->x       # getter (0 args)
$p->x(3.0)    # setter (1 arg)

User-defined methods:

struct Circle {
    radius => Float,
    fn area { 3.14159 * $self->radius ** 2 }
    fn scale($factor: Float) {
        Circle(radius => $self->radius * $factor)
    }
}
my $c = Circle(radius => 5)
p $c->area        # 78.53975
p $c->scale(2)    # Circle(radius => 10)

Built-in methods:

my $q = $p->with(x => 5)  # functional update — new instance
my $h = $p->to_hash       # { x => 1.5, y => 2.0 }
my @f = $p->fields        # (x, y)
my $c = $p->clone         # deep copy

Smart stringify:

p $p  # Point(x => 1.5, y => 2)

Structural equality:

my $x = Point(1, 2)
my $y = Point(1, 2)
p $x == $y  # 1 (compares all fields)

Note: field type is checked at construction and mutation; unknown field names are fatal errors.

# typed

typed adds optional runtime type annotations to lexical variables and subroutine parameters. When a typed declaration is in effect, stryke inserts a lightweight check at assignment time that verifies the value matches the declared type (Int, Str, Float, Bool, ArrayRef, HashRef, or a user-defined struct name). This is especially useful for catching accidental type mismatches at function boundaries in larger programs. The annotation is purely a runtime guard — it has zero impact on pipeline performance because the check is only performed once at the point of assignment, not on every read.

typed my $x : Int = 42
typed my $name : Str = "hello"
typed my $pi : Float = 3.14
my $add = fn ($x: Int, $y: Int) { $x + $y }
p $add->(3, 4)   # 7

Note: assigning a value of the wrong type raises a runtime exception immediately.

You can mix typed and untyped variables freely in the same scope, so adopting typed is incremental — annotate the variables that matter and leave the rest dynamic. Subroutine parameters declared with type annotations in fn are checked on every call, giving you contract-style validation at function boundaries without a separate assertion library.

typed my @nums : Int = (1, 2, 3)
typed my %cfg : Str = (host => "localhost", port => "8080")

# match

Algebraic pattern matching (stryke extension).

match ($val) {
    /^\d+$/ => p "number: $val",
    [1, 2, _] => p "array starting with 1,2",
    { name => $n } => p "name is $n",
    _ => p "default",
}

Patterns: regex, array, hash, literal, wildcard _. Optional if guard per arm.

Caveat — topic shadowing inside arms: inside each arm, _ rebinds to the *matched* value (a regex string, an array element, a hash slot), not the outer function's _ topic. If you need both the matched value and the outer topic, capture the outer one before the match:

fn process_event {
    my $e = _                    # capture outer topic
    match ($e->{type}) {
        "LOGIN" => "user #{ $e->{user} } logged in",   # ← $e, not _
        _       => "unknown",
    }
}

# frozen

Declare an immutable lexical variable. const my and frozen my are interchangeable spellings; const reads more naturally for engineers coming from other languages.

const my $pi = 3.14159
# $pi = 3  # ERROR: cannot assign to frozen variable

frozen my @primes = (2, 3, 5, 7, 11)

# fore

Side-effect-only list iterator (like map but void, returns item count).

qw(a b c) |> e p           # prints a, b, c; returns 3
1:5 |> map _ * 2 |> e p  # prints 2,4,6,8,10

# ep

ep — shorthand for e { p } (foreach + print). Iterates the list and prints each element.

qw(a b c) |> ep            # prints a, b, c (one per line)
filef |> sorted |> ep      # print sorted file list
1:5 |> map _ * 2 |> ep   # prints 2,4,6,8,10

# p

p — the stryke print-with-newline verb. Costs one character, has the record separator built in, and is the canonical output primitive: every example, hover doc, and rosetta program in the corpus uses p. With multiple args, joins them with $, (default empty) and appends $\ (default \n). Stringifies refs as HASH(0x…) / ARRAY(0x…); use ep / ddump / to_json for structured dumps.

p "hello"          # hello\n
p 42               # 42\n
p "x=", $x, " y=", $y      # multi-arg, joined by $,
1:5 |> e p              # iterate + p — prints one per line
@xs |> ep                # shorthand for `|> e p`
p "#{ sum @arr }"       # interpolation

p is preferred over Perl 5's print and say in every stryke context:

| Form | Status | |---|---| | p "x" | stryke canonical — one char, includes newline, no flags | | print "x\n" | Perl 5 compat — keeps working under --compat, but reads as legacy | | say "x" | Rejected by --no-interop. Perl 5.10 keyword; p exists precisely to replace it |

p is NOT "an alias for say" — it's the primary spelling. say is the rejected Perl 5 form. Use p.

See also: ep (each-then-p), pp (pretty-print), ddump (full structure dump), warn (stderr equivalent of p).

# gen

Create a generator — lazy yield values on demand.

my $g = gen { yield _ for 1:5 }
my ($val, $more) = @{$g->next}

# yield

Yield a value from inside a gen { } generator block, suspending the generator until the consumer calls ->next again. Each yield produces one element in the lazy sequence. When the block finishes without yielding, the generator signals exhaustion. This is the stryke equivalent of Python's yield or Rust's Iterator::next.

my $fib = gen {
    my ($x, $y) = (0, 1)
    while (1) {
        yield $x
        ($x, $y) = ($y, $x + $y)
    }
}
for (1:10) {
    my ($val) = @{$fib->next}
    p $val
}

# trace

trace { BLOCK } — enable shared-state mutation tracing for the duration of BLOCK. Every read/write of a mysync/oursync variable (including compound ops like ++, +=, .=) is logged to STDERR with the worker index, value before, and value after. Invaluable for debugging races, dropped updates, or compound-op atomicity violations.

Outside trace, the same operations run with zero overhead — trace is the only way to switch the instrumentation on.

mysync $counter = 0
trace {
    fan 10 { $counter++ }       # 10 workers, each prints "<w> ++ : N → N+1"
}
p $counter                       # 10

# Diagnose a missed update:
mysync %hits = ()
trace { fan 100 { $hits{rand(10)}++ } }

For function-call tracing (every named-fn entry/exit) use --profile or AOP before/after. For low-level VM op tracing use --trace-ops.

See also: mysync, oursync, fan, AOP before/after.

# timer

timer { BLOCK } — measure the wall-clock elapsed time of BLOCK and return the duration in milliseconds (f64). The block's own return value is discarded; use timed if you need both. Internally std::time::Instant::now brackets the block, so resolution is the host's monotonic clock (sub-microsecond on modern CPUs).

my $ms = timer { sort_huge_list() }
printf "sort took %.2f ms\n", $ms

# Compare two implementations:
my $a = timer { algorithm_a(@data) }
my $b = timer { algorithm_b(@data) }
printf "speedup: %.2fx\n", $a / $b

For statistical benchmarking (warmup, min / mean / p99), use bench instead. For per-operation profiling use --profile or trace.

See also: bench, eval_timeout, time, now_ns.

# bench

Benchmark a block N times; returns "min/mean/p99".

my $report = bench { work() } 1000

# eval_timeout

Run a block with a wall-clock timeout (seconds).

eval_timeout 5 { slow_operation() }

# retry

Retry a block on failure.

retry { http_call() } times => 3, backoff => 'exponential'

# rate_limit

rate_limit(N, "WINDOW") { BLOCK } — token-bucket throttle: run the body at most N times per WINDOW. Excess calls block until a token is available rather than failing — guarantees the rate without dropping work. WINDOW accepts "500ms", "1s", "5m", "1h", or a bare number of seconds. The throttle state is per-call-site, so multiple rate_limit blocks at different sites have independent buckets.

# Cap API calls at 10/sec — the 11th waits until a token frees up.
for my $url (@urls) {
    rate_limit(10, "1s") { fetch($url) }
}

# Long window — at most 1 nightly job per hour even under retries.
rate_limit(1, "1h") { nightly_compaction() }

# Inside a parallel iter (mysync bucket — actually shared across workers).
pfor { rate_limit(50, "1s") { ingest($_) } } @records

For non-blocking probe-style throttling (test if a token is available, drop instead of waiting) use try_acquire. For bulk burst handling use a pchannel of capacity N as a hand-rolled bucket.

See also: every, retry, circuit_breaker, semaphore.

# every

every "INTERVAL" { BLOCK } — run BLOCK repeatedly with at least INTERVAL between iterations. INTERVAL accepts "500ms", "1s", "5m", etc. Runs *forever* on the calling thread by default; combine with last/die from inside the block to exit, or with spawn { every … } to run in the background.

# Tick the heartbeat every second.
every "1s" { p "alive at " . now }

# Background poll — quits cleanly when state.done.
spawn {
    every "500ms" {
        last if $shared->{done}
        update_dashboard()
    }
}

# Fixed-delta scheduler — actually-tick exactly every N ms even if BLOCK is slow.
every "100ms" { check_health() }       # next tick = previous start + 100ms

For one-shot delayed execution use sleep + a normal call. For wall-clock-aligned ticks (every minute at :00) use cron.

See also: sleep, rate_limit, eval_timeout, cron.

# watch

watch PATH, fn { … } — register a filesystem watcher on PATH (file or directory) and invoke the callback whenever the path is modified. Inside the callback, _ is the absolute path of the changed file. Blocks the calling thread; combine with spawn to watch in the background.

Uses the OS-native facility (FSEvents on macOS, inotify on Linux). Recursive on directories; not recursive on files. The callback fires for every event, so debounce inside the body if you only want a single rebuild after a burst.

# Live recompile loop
watch "src/", fn {
    next unless _ =~ /\.rs$/
    p "changed: $_"
    system "cargo", "build"
}

# Background watcher
spawn {
    watch "config.toml", fn { reload_config() }
}

# Debounce trailing edge — coalesce bursts into one rebuild every 250ms.
mysync $last = 0
watch ".", fn {
    my $now = now_ns()
    if ($now - $last > 250_000_000) {
        $last = $now
        rebuild()
    }
}

For parallel multi-path watching use par_watch. For poll-based watching that doesn't need OS support use every "1s" { stat … }.

See also: par_watch, every, spawn.

# capture

Run a command and capture structured output. Returns an object with ->stdout, ->stderr, ->exitcode, and ->failed methods. When piped to lines or words, stdout is auto-extracted so you can chain directly.

my $r = capture("ls -la")
p $r->stdout, $r->stderr, $r->exitcode
capture("ps aux") |> lines |> map { columns } |> tbl |> p

# json_encode

json_encode serializes any stryke data structure — hashrefs, arrayrefs, nested combinations, numbers, strings, booleans, and undef — into a compact JSON string. Native bare-name builtin backed by a Rust serializer; no module to import. The output is always valid UTF-8 JSON suitable for writing to files, sending over HTTP, or piping to other tools. Use json_decode to round-trip back.

my %cfg = (debug => 1, paths => ["/tmp", "/var"])
my $j = json_encode(\%cfg)
p $j   # {"debug":1,"paths":["/tmp","/var"]}
$j |> spurt "/tmp/cfg.json"$1

Note: undef becomes JSON `null`; booleans serialize as `true`/`false`.

# json_decode

json_decode parses a JSON string and returns the corresponding Perl data structure — hashrefs for objects, arrayrefs for arrays, and native scalars for strings/numbers/booleans. It is strict by default: malformed JSON raises an exception rather than returning partial data. This makes it safe to use in pipelines where corrupt input should halt processing. The Rust parser underneath handles large documents efficiently and supports full Unicode.

my $data = json_decode('{"name":"stryke","ver":1}')
p $data->{name}   # stryke
slurp("data.json") |> json_decode |> dd$1

Note: JSON `null` becomes Perl `undef`; trailing commas and comments are not allowed.

# json_jq

json_jq applies a jq-style query expression to a stryke data structure and returns the matched value. This brings the power of the jq command-line JSON processor directly into stryke without shelling out. Dot notation traverses hash keys, bracket notation indexes arrays, and nested paths are separated by dots. It is ideal for extracting deeply nested values from API responses or config files without chains of hash dereferences.

my $data = json_decode(slurp "api.json")
p json_jq($data, ".results[0].name")
my $cfg = rj "config.json"
p json_jq($cfg, ".database.host")  # deep extract
fetch_json("https://api.example.com/users") |> json_jq(".data[0].email") |> p

# to_json

to_json (alias tj) converts a stryke data structure into a JSON string, functioning as a convenient shorthand for json_encode. It accepts hashrefs, arrayrefs, scalars, and nested combinations, producing compact JSON output suitable for APIs, config files, or inter-process communication. The alias tj is particularly useful at the end of a pipeline to serialize the final result. The Rust-backed serializer handles large structures efficiently and always produces valid UTF-8.

my %user = (name => "Bob", age => 30)
p tj \%user   # {"age":30,"name":"Bob"}
my @items = map { {id => _, val => _ * 2} } 1:3
p tj \@items  # [{"id":1,"val":2},{"id":2,"val":4},{"id":3,"val":6}]
@data |> tj |> spurt "out.json"

# to_csv

to_csv (alias tc) serializes a list of hashrefs or arrayrefs into a CSV-formatted string, complete with a header row derived from hash keys when given hashrefs. This is the fastest way to produce spreadsheet-ready output from structured data. Fields containing commas, quotes, or newlines are automatically escaped according to RFC 4180. The alias tc keeps one-liners terse when piping query results or API responses straight to CSV.

my @rows = ({name => "Alice", age => 30}, {name => "Bob", age => 25})
p tc \@rows   # name,age\nAlice,30\nBob,25
tc(\@rows) |> spurt "people.csv"
my @grid = ([1, 2, 3], [4, 5, 6])
p tc \@grid   # 1,2,3\n4,5,6

# to_toml

to_toml (alias tt) serializes a stryke hashref into a TOML-formatted string. TOML is a popular configuration format that maps cleanly to hash structures, making tt ideal for generating config files programmatically. Nested hashes become TOML sections, arrays become TOML arrays, and scalar values are serialized with their natural types. The output is always valid TOML that can be parsed back with toml_decode.

my %cfg = (database => {host => "localhost", port => 5432}, debug => 1)
p tt \%cfg
# [database]
# host = "localhost"
# port = 5432
# debug = 1
tt(\%cfg) |> spurt "config.toml"

# to_yaml

to_yaml (alias ty) serializes a stryke data structure into a YAML-formatted string. YAML is widely used for configuration and data exchange where human readability matters. Nested structures are represented with indentation, arrays with leading dashes, and strings are quoted only when necessary. The output is valid YAML 1.2 that round-trips cleanly through yaml_decode. The alias ty is convenient for quick inspection of complex data.

my %app = (name => "myapp", deps => ["tokio", "serde"], version => "1.0")
p ty \%app
# name: myapp
# version: "1.0"
# deps:
#   - tokio
#   - serde
ty(\%app) |> spurt "app.yaml"

# to_xml

to_xml (alias tx) serializes a stryke data structure into an XML string. Hash keys become element names, array values become repeated child elements, and scalar values become text content. This is useful for generating XML payloads for SOAP APIs, RSS feeds, or configuration files that require XML format. The output is well-formed XML that can be parsed back with xml_decode.

my %doc = (root => {title => "Hello", items => ["a", "b", "c"]})
p tx \%doc
# <root><title>Hello</title><items>a</items><items>b</items><items>c</items></root>
tx(\%doc) |> spurt "doc.xml"

# to_html

to_html (alias th) serializes a stryke data structure into a self-contained HTML document with cyberpunk styling (dark background, neon cyan/magenta accents, monospace fonts). Arrays of hashrefs render as full tables with headers, plain arrays as bullet lists, single hashes as key-value tables, and scalars as styled text blocks. Pipe to a file and open in a browser for instant data visualization.

fr |> map +{name => _, size => format_bytes(size)} |> th |> to_file("report.html")
my @rows = ({name => "Alice", age => 30}, {name => "Bob", age => 25})
@rows |> th |> to_file("people.html")
th({host => "localhost", port => 5432}) |> p

# to_markdown

to_markdown (aliases to_md, tmd) serializes a stryke data structure into Markdown text. Arrays of hashrefs render as GFM tables with headers and separator rows, plain arrays as bullet lists, single hashes as 2-column key-value tables, and scalars as plain text. The output is valid GitHub-Flavored Markdown suitable for README files, issue comments, or any Markdown renderer.

fr |> map +{name => _, size => format_bytes(size)} |> tmd |> to_file("report.md")
my @rows = ({name => "Alice", age => 30}, {name => "Bob", age => 25})
@rows |> tmd |> p
# | name | age |
# | --- | --- |
# | Alice | 30 |
# | Bob | 25 |

# from_json

from_json (alias fj) parses a JSON string into a stryke data structure (hashref, arrayref, scalar). This is the inverse of to_json and the idiomatic way to decode JSON responses from APIs, config files, or inter-process communication. The Rust-backed parser handles large documents efficiently.

my $json = '{"name":"Alice","age":30}'
my $data = from_json($json)
p $data->{name}   # Alice
my $arr = fj '[1, 2, {"x": 3}]'
p $arr->[2]{x}    # 3
slurp("config.json") |> fj

# from_yaml

from_yaml (alias fy) parses a YAML string into a stryke data structure. YAML is commonly used for configuration files due to its human-readable syntax. Handles scalars, arrays, hashes, and nested combinations. The parser supports common YAML features like multi-line strings and bare unquoted keys.

my $yaml = "name: Alice\nage: 30"
my $data = from_yaml($yaml)
p $data->{name}   # Alice
slurp("config.yaml") |> fy |> say _->{database}{host}

# from_toml

from_toml (alias ftoml) parses a TOML string into a stryke hashref. TOML is popular for Rust, Python, and other config files due to its explicit syntax. Sections become nested hashes, arrays stay arrays, and typed values (integers, floats, strings, booleans) are preserved.

my $toml = "[package]\nname = \"myapp\"\nversion = \"1.0\""
my $data = from_toml($toml)
p $data->{package}{name}   # myapp
slurp("Cargo.toml") |> ftoml |> say _->{package}{version}

# from_xml

from_xml (alias fx) parses an XML string into a stryke hashref. Element names become hash keys, text content becomes string values, nested elements become nested hashes. The parser handles the XML declaration and basic structures.

my $xml = '<root><name>Alice</name><age>30</age></root>'
my $data = from_xml($xml)
p $data->{root}{name}   # Alice
slurp("config.xml") |> fx |> say _->{config}{database}{host}

# from_csv

from_csv (alias fcsv) parses a CSV string into an arrayref of hashrefs, treating the first line as headers. This is the inverse of to_csv and handles quoted fields containing commas according to RFC 4180.

my $csv = "name,age\nAlice,30\nBob,25"
my $rows = from_csv($csv)
p $rows->[0]{name}   # Alice
p $rows->[1]{age}    # 25
slurp("data.csv") |> fcsv |> grep { _->{age} > 25 }

# xopen

xopen (alias xo) opens a file or URL with the system default handler — open on macOS, xdg-open on Linux, start on Windows. Returns the path unchanged so it can sit transparently in a pipeline. This is the missing link between generating output files and viewing them: pipe the path through xopen and the OS opens it in the appropriate app (browser for HTML, viewer for PDF, editor for text).

fr |> map +{name => _, size => format_bytes(size)} |> th |> to_file("report.html") |> xopen
xopen "https://example.com"
xopen "output.pdf"

# clip

clip (aliases clipboard, pbcopy) copies text to the system clipboard (pbcopy on macOS, xclip/xsel on Linux). Returns the text unchanged for pipeline chaining. This is the missing link between generating output and sharing it — pipe any serializer's output through clip and paste directly into Slack, GitHub, docs, or email.

fr |> map +{name => _, size => format_bytes(size)} |> tmd |> clip   # markdown table → clipboard
qw(a b c) |> join "," |> clip |> p                                  # also prints
"some text" |> clip                                                  # just copy

# paste

paste (alias pbpaste) reads text from the system clipboard (pbpaste on macOS, xclip/xsel on Linux). Returns the clipboard contents as a string, ready for pipeline processing.

p paste                              # print clipboard contents
paste |> lines |> grep /error/i |> p  # search clipboard for errors
paste |> wc |> p                      # word count of clipboard

# to_table

to_table (aliases table, tbl) renders data as a plain-text column-aligned table with Unicode box-drawing borders. Arrays of hashrefs render as full tables with headers, plain arrays as numbered rows, single hashes as key-value tables sorted by numeric value descending (ties by key), matching freq → tbl expectations. The output is fixed-width text suitable for terminal display, log files, or any monospace context.

my @r = ({name => "Alice", age => 30}, {name => "Bob", age => 25})
@r |> tbl |> p
# ┌───────┬─────┐
# │ name  │ age │
# ├───────┼─────┤
# │ Alice │ 30  │
# │ Bob   │ 25  │
# └───────┴─────┘
fr |> map +{name => _, size => format_bytes(size)} |> tbl |> p

# sparkline

sparkline (alias spark) renders a list of numbers as a compact Unicode sparkline string using block characters (▁▂▃▄▅▆▇█). Each value maps to a bar height proportional to the min/max range. Ideal for inline data visualization in terminal output, dashboards, or log summaries.

(3,7,1,9,4,2,8,5) |> spark |> p   # ▃▆▁█▄▂▇▅
@daily_sales |> spark |> p         # quick trend line
fr |> map { size } |> spark |> p   # file size distribution

# bar_chart

bar_chart (alias bars) renders a hashref as a colored horizontal bar chart in the terminal. Each key becomes a label, each value a proportional bar. Colors cycle automatically. Pairs naturally with freq for instant word/event counting visualization.

qw(a b a c a b) |> freq |> bars |> p
# a │ ████████████████████████████████████████ 3
# b │ ███████████████████████████ 2
# c │ █████████████ 1
bars({cpu => 73, mem => 45, disk => 91}) |> p

# flame

flame (alias flamechart) renders a hierarchical hashref as a terminal flamechart with colored stacked bars. Nested hashes become child rows; widths are proportional to leaf values (weights). Useful for visualizing call stacks, cost breakdowns, or any tree-structured data.

flame({main => {parse => 30, eval => {compile => 15, run => 45}}, init => 10}) |> p
my $profile = read_json "profile.json"
flame($profile) |> p

# histo

histo renders a vertical histogram in the terminal. Given a hashref (label → count), it draws colored vertical bars. Given a flat array of numbers, it auto-bins into 10 buckets and shows the distribution. Pairs with freq for categorical data.

qw(a b a c a b) |> freq |> histo |> p   # vertical bars for a/b/c
(map { int(rand(100)) } 1:1000) |> histo |> p  # distribution of randoms

# gauge

gauge renders a single value as a horizontal gauge bar with color coding (green ≥80%, yellow ≥50%, magenta ≥25%, red below). Accepts a fraction (0.0–1.0) or a value with max: gauge(45, 100).

p gauge(0.73)       # [██████████████████████░░░░░░░░] 73%
p gauge(45, 100)    # [█████████████░░░░░░░░░░░░░░░░] 45%

# spinner

spinner shows an animated braille spinner on stderr while a block executes, then clears the spinner and returns the block's result. Useful for long-running one-liners where you want visual feedback without polluting stdout.

my $r = spinner "loading" { fetch_json("https://api.example.com/data") }
spinner { sleep 2
    42 }   # default message "working"

# csv_read

csv_read (alias cr) reads CSV data from a file path or string and returns an array of arrayrefs, where each inner arrayref represents one row. The parser handles RFC 4180 CSV correctly — quoted fields with embedded commas, newlines inside quotes, and escaped double quotes are all supported. The first row is treated as data (not a header) unless you process it separately. This is the fastest way to ingest tabular data in stryke.

my @rows = csv_read "data.csv"
p $rows[0]             # first row as arrayref
@rows |> e { p _->[0] }  # print first column
my @inline = csv_read "a,b,c\n1,2,3\n4,5,6"
p scalar @inline       # 3 rows (including header)

# csv_write

csv_write (alias cw) serializes an array of arrayrefs into a CSV-formatted string. Each inner arrayref becomes one row, and fields are automatically quoted when they contain commas, quotes, or newlines. This is the complement of csv_read and produces output conforming to RFC 4180. Use it to generate CSV files from computed data, export database query results, or prepare data for spreadsheet import.

my @data = (["name", "age"], ["Alice", 30], ["Bob", 25])
csv_write(\@data) |> spurt "people.csv"
my @report = map { [_->{id}, _->{score}] } @results
p csv_write \@report

# dataframe

dataframe (alias df) creates a columnar dataframe from tabular data, providing a structured way to work with rows and columns. You can construct a dataframe from an array of hashrefs, an array of arrayrefs with a header row, or from a CSV file. The dataframe supports column selection, filtering, sorting, and aggregation operations. This is stryke's answer to Python's pandas DataFrame — lightweight but sufficient for common data manipulation tasks.

my $df = df [{name => "Alice", age => 30}, {name => "Bob", age => 25}]
p $df
my $df2 = df csv_read "data.csv"
my @ages = $df->{age}
p @ages   # 30, 25

# sqlite

sqlite (alias sql) executes a SQL statement against an SQLite database file and returns the results. For SELECT queries, it returns an array of hashrefs where each hashref represents one row with column names as keys. For INSERT, UPDATE, and DELETE statements, it returns the number of affected rows. Bind parameters prevent SQL injection and handle quoting automatically. The database file is created if it does not exist, making sqlite a zero-setup embedded database.

sqlite("app.db", "CREATE TABLE users (name TEXT, age INT)")
sqlite("app.db", "INSERT INTO users VALUES (?, ?)", "Alice", 30)
my @rows = sqlite("app.db", "SELECT * FROM users WHERE age > ?", 20)
@rows |> e { p _->{name} }
sqlite("app.db", "SELECT count(*) as n FROM users") |> dd

# digits

digits (alias dg) extracts all digit characters from a string and returns them as a list. This is a quick way to pull numbers out of mixed text without writing a regex. Pairs naturally with join to reconstruct the numeric string, or freq for digit distribution analysis.

p join "", digits("phone: 555-1234")     # 5551234
"abc123def456" |> digits |> cnt |> p     # 6
cat("log.txt") |> digits |> freq |> bars |> p

# letters

letters (alias lts) extracts all alphabetic characters from a string and returns them as a list. Filters out digits, punctuation, whitespace — keeps only letters.

p join "", letters("h3ll0 w0rld!")   # hllwrld
"abc123DEF" |> letters |> cnt |> p   # 6

# sentences

sentences (alias sents) splits text on sentence boundaries (. ! ? followed by whitespace or end of string). Returns a list of trimmed sentences. Useful for NLP pipelines, text analysis, or splitting prose into processable units.

"Hello world. How are you? Fine!" |> sentences |> e p
# Hello world.
# How are you?
# Fine!
cat("essay.txt") |> sentences |> cnt |> p    # sentence count

# paragraphs

paragraphs (alias paras) splits text on blank lines (one or more consecutive newlines). Returns a list of trimmed paragraph strings. Useful for processing structured documents, README files, or any text with paragraph breaks.

cat("README.md") |> paragraphs |> cnt |> p   # paragraph count
cat("essay.txt") |> paragraphs |> map { sentences |> cnt } |> spark |> p  # sentences per paragraph

# sections

sections (alias sects) splits text on markdown-style headers (# ..., ## ...) or lines of ===/---. Returns a list of arrayrefs [heading, body] where each section's heading and body are separated. Useful for parsing structured documents.

cat("README.md") |> sections |> cnt |> p     # section count
cat("README.md") |> sections |> map { _->[0] } |> e p  # list all headings

# numbers

numbers (alias nums) extracts all numbers (integers and floats, including negatives) from a string and returns them as numeric values. Unlike digits which returns individual digit characters, numbers returns actual parsed values. Useful for pulling measurements, scores, or IDs out of mixed text.

p join ",", numbers("temp 98.6F, -20C, ver 3")  # 98.6,-20,3
cat("log.txt") |> numbers |> avg |> p              # average of all numbers in file
"price: $12.99 qty: 5" |> numbers |> e p            # 12.99, 5

# graphemes

graphemes (alias grs) splits a string into Unicode grapheme clusters. Unlike chars which splits on code points, graphemes keeps combining marks and emoji sequences together as single visual units. "cafe\u{0301}" gives 4 graphemes (not 5 code points). Essential for correct text processing of accented characters, emoji, and non-Latin scripts.

p cnt graphemes("cafe\u{0301}")    # 4 (not 5)
graphemes("hello") |> e p          # h, e, l, l, o

# columns

columns (alias cols) splits fixed-width columnar text into fields. Without a widths argument, it auto-detects columns by splitting on runs of 2+ whitespace (ideal for ps aux, ls -l, df output). With an arrayref of widths, it splits at exact fixed positions. Pairs with lines for processing tabular command output.

my @fields = columns("USER  PID  %CPU")             # auto-detect: [USER, PID, %CPU]
my @fixed = columns("John   Doe   30", [7, 7, 3])   # fixed-width: [John, Doe, 30]
capture("ps aux") |> lines |> map { columns } |> tbl |> p

# stringify

stringify (alias str) converts any stryke value — scalars, array refs, hash refs, nested structures, undef — into a string representation that is a valid stryke literal. The output is designed for round-tripping: you can eval the returned string to reconstruct the original data structure. This makes it ideal for serializing state to a file in a Perl-native format, generating code fragments, or building reproducible test fixtures. Unlike dd, which targets human readability, str prioritizes parseability.

my $s = str {a => 1, b => [2, 3]}
p $s               # {a => 1, b => [2, 3]}
my $copy = eval $s # round-trip back to hashref
my @list = (1, "hello", undef)
p str \@list        # [1, "hello", undef]

Note: references are serialized recursively; circular references will cause infinite recursion.

# ddump

ddump (alias dd) pretty-prints any stryke data structure to stderr in a human-readable, indented format. Native bare-name builtin — no module to import. It is the go-to tool for quick debugging — drop a dd call anywhere in a pipeline to inspect intermediate values without disrupting the data flow. The output is colorized when stderr is a terminal. Unlike str, the output is not meant for eval round-tripping; it prioritizes clarity over parseability. dd returns its argument unchanged, so it can be inserted into pipelines transparently.

my %h = (name => "Alice", scores => [98, 87, 95])
dd \%h                        # pretty-prints to stderr
my @result = @data |> dd |> grep { _->{active} } |> dd
dd [1, {a => 2}, [3, 4]]     # nested structure

Note: dd writes to stderr, not stdout, so it never contaminates pipeline output.

# toml_decode

toml_decode (alias td) parses a TOML-formatted string and returns the corresponding stryke hash structure. TOML sections become nested hashrefs, arrays map to arrayrefs, and typed scalars (integers, floats, booleans, datetime strings) are preserved. This is useful for reading configuration files, parsing Cargo.toml manifests, or processing any TOML input. Malformed TOML raises an exception.

my $cfg = toml_decode(slurp "config.toml")
p $cfg->{database}{host}   # localhost
my $cargo = toml_decode(slurp "Cargo.toml")
p $cargo->{package}{version}
slurp("settings.toml") |> toml_decode |> dd

# toml_encode

toml_encode (alias te) serializes a stryke hashref into a valid TOML string. Nested hashes become TOML sections with [section] headers, arrays become TOML arrays, and scalars are serialized with appropriate quoting. This is the inverse of toml_decode and is useful for generating or updating configuration files programmatically. The output is human-readable and can be written directly to a .toml file.

my %cfg = (server => {host => "0.0.0.0", port => 8080}, debug => 0)
toml_encode(\%cfg) |> spurt "server.toml"
my $round = toml_decode(toml_encode(\%cfg))
p $round->{server}{port}  # 8080

# yaml_decode

yaml_decode (alias yd) parses a YAML string and returns the corresponding stryke data structure. Mappings become hashrefs, sequences become arrayrefs, and scalars are coerced to their natural Perl types. This handles YAML 1.2 including multi-document streams, anchors/aliases, and flow notation. It is the go-to function for reading YAML configuration files, Kubernetes manifests, or CI pipeline definitions. Invalid YAML raises an exception.

my $cfg = yaml_decode(slurp "docker-compose.yml")
p $cfg->{services}{web}{image}
my $ci = yaml_decode(slurp ".github/workflows/ci.yml")
dd $ci->{jobs}
slurp("values.yaml") |> yaml_decode |> json_encode |> p

# yaml_encode

yaml_encode (alias ye) serializes a stryke data structure into a valid YAML string. Hashes become YAML mappings, arrays become sequences with dash prefixes, and scalars are quoted only when necessary for disambiguation. The output is human-readable and suitable for writing config files, generating Kubernetes resources, or producing YAML-based API payloads. It is the inverse of yaml_decode.

my %svc = (name => "api", replicas => 3, ports => [80, 443])
yaml_encode(\%svc) |> spurt "service.yaml"
my $round = yaml_decode(yaml_encode(\%svc))
p $round->{replicas}   # 3
rj("config.json") |> yaml_encode |> p  # JSON to YAML

# xml_decode

xml_decode (alias xd) parses an XML string and returns a stryke data structure. Elements become hash keys, text content becomes scalar values, repeated child elements become arrayrefs, and attributes are accessible through a conventions-based mapping. This is useful for consuming SOAP responses, RSS feeds, SVG files, or any XML-based API. Malformed XML raises an exception rather than returning partial data.

my $doc = xml_decode('<root><name>stryke</name><ver>1</ver></root>')
p $doc->{root}{name}   # stryke
slurp("feed.xml") |> xml_decode |> dd
my $svg = xml_decode(fetch("https://example.com/image.svg"))
p $svg->{svg}

# xml_encode

xml_encode (alias xe) serializes a stryke data structure into a well-formed XML string. Hash keys become element names, scalar values become text content, and arrayrefs become repeated sibling elements. This is useful for generating XML payloads for SOAP APIs, creating RSS or Atom feeds, or producing configuration files in XML format. The output is the inverse of xml_decode and round-trips cleanly.

my %data = (root => {title => "Test", items => [{id => 1}, {id => 2}]})
p xml_encode \%data
xml_encode(\%data) |> spurt "output.xml"
my $payload = xml_encode {request => {action => "query", id => 42}}
http_request(method => "POST", url => $endpoint, body => $payload)

# fetch

fetch (alias ft) performs a blocking HTTP GET request to the given URL and returns the response body as a string. It follows redirects automatically and raises an exception on network errors or non-2xx status codes. This is the simplest way to retrieve content from the web in stryke — no need to configure a client or parse response objects. For JSON APIs, prefer fetch_json which additionally decodes the response.

my $html = fetch "https://example.com"
p $html
my $ip = fetch "https://api.ipify.org"
p "My IP: $ip"
fetch("https://example.com/data.txt") |> spurt "local.txt"$1

Note: for POST, PUT, DELETE, or custom headers, use `http_request` instead.

# fetch_json

fetch_json (alias ftj) performs a blocking HTTP GET request and automatically decodes the JSON response body into a stryke data structure. This combines fetch and json_decode into a single call, which is the common case when consuming REST APIs. It raises an exception if the response is not valid JSON or the request fails. The returned value is typically a hashref or arrayref ready for immediate use.

my $data = fetch_json "https://api.github.com/repos/stryke/stryke"
p $data->{stargazers_count}
fetch_json("https://jsonplaceholder.typicode.com/todos") |> e { p _->{title} }
my $weather = fetch_json "https://wttr.in/?format=j1"
p $weather->{current_condition}[0]{temp_C}

# fetch_async

fetch_async (alias fta) initiates a non-blocking HTTP GET request and returns a task handle that can be awaited later. This allows you to fire off multiple HTTP requests concurrently and wait for them all to complete, dramatically reducing total latency when fetching from several endpoints. The task resolves to the response body as a string, just like fetch. Use this when you need to parallelize network I/O without threads.

my $t1 = fetch_async "https://api.example.com/users"
my $t2 = fetch_async "https://api.example.com/posts"
my $users = await $t1
my $posts = await $t2
p "Got users and posts concurrently"

# fetch_async_json

fetch_async_json (alias ftaj) initiates a non-blocking HTTP GET request that automatically decodes the JSON response when awaited. This combines fetch_async with json_decode, making it the ideal choice for concurrent API calls where every response is JSON. The task resolves to the decoded stryke data structure — a hashref, arrayref, or scalar depending on the JSON content.

my @urls = map { "https://api.example.com/item/$_" } 1:10
my @tasks = map fetch_async_json @urls
my @results = map await @tasks
@results |> e { p _->{name} }

# http_request

http_request (alias hr) performs a fully configurable HTTP request with control over method, headers, body, and timeout. Unlike fetch which is limited to GET, http_request supports POST, PUT, PATCH, DELETE, and any other HTTP method. Pass named parameters for configuration. The response is returned as a hashref containing status, headers, and body fields, giving you full access to the HTTP response. This is the right tool when you need to send data, set authentication headers, or inspect status codes.

my $res = http_request(method => "POST", url => "https://api.example.com/users",
    headers => {"Content-Type" => "application/json", Authorization => "Bearer $token"},
    body => tj {name => "Alice"})
p $res->{status}   # 201
my $data = json_decode $res->{body}
my $del = http_request(method => "DELETE", url => "https://api.example.com/users/42")

# par_fetch

par_fetch @urls — fetch a list of URLs in parallel using async HTTP, returning an array of response bodies in input order.

Under the hood, stryke spawns concurrent HTTP GET requests across a connection pool with keep-alive and automatic retry on transient failures (5xx, timeouts). The degree of parallelism is bounded by the connection pool size (default 64) to avoid overwhelming the target server. For heterogeneous HTTP methods or custom headers, use http_request inside pmap instead. par_fetch is the right tool when you have a homogeneous list of URLs and just need the bodies — it handles connection reuse, DNS caching, and TLS session resumption automatically for maximum throughput.

my @bodies = par_fetch @urls

# Fetch and decode JSON in one shot:
my @data = par_fetch(@api_urls) |> map json_decode

# Download pages with progress:
my @pages = par_fetch @urls, progress => 1

# serve

Start a blocking HTTP server.

serve 8080, fn ($req) {
    # $req = { method, path, query, headers, body, peer }
    { status => 200, body => "hello" }
}

serve 3000, fn ($req) {
    my $data = { name => "stryke", version => "0.4" }
    { status => 200, body => json_encode($data) }
}, { workers => 8 }$1

Handler returns: hashref `{ status, body, headers }`, string (200 OK), or undef (404).
JSON content-type auto-detected when body starts with `{` or `[`.

# socket

Create a network socket with the specified domain, type, and protocol. The socket handle is stored in the first argument and can then be used with bind, connect, send, recv, and other socket operations. Domain constants include AF_INET (IPv4) and AF_INET6 (IPv6); type constants include SOCK_STREAM (TCP) and SOCK_DGRAM (UDP).

socket(my $sock, AF_INET, SOCK_STREAM, 0)
my $addr = sockaddr_in(8080, inet_aton("127.0.0.1"))
connect($sock, $addr)
send($sock, "GET / HTTP/1.0\r\n\r\n", 0)

# bind

Bind a socket to a local address so it can accept connections or receive datagrams on that address. The address is a packed sockaddr_in or sockaddr_in6 structure. Binding is required before calling listen on a server socket. Dies if the address is already in use unless SO_REUSEADDR is set.

socket(my $srv, AF_INET, SOCK_STREAM, 0)
setsockopt($srv, SOL_SOCKET, SO_REUSEADDR, 1)
bind($srv, sockaddr_in(8080, INADDR_ANY)) or die "bind: $!"
listen($srv, 5)

# listen

Mark a bound socket as passive, ready to accept incoming connections. The backlog argument specifies the maximum number of pending connections the OS will queue before refusing new ones. This is only meaningful for stream (TCP) sockets. Call accept in a loop after listen to handle clients.

socket(my $srv, AF_INET, SOCK_STREAM, 0)
bind($srv, sockaddr_in(9000, INADDR_ANY))
listen($srv, 128) or die "listen: $!"
while (accept(my $client, $srv)) {
    send($client, "hello\n", 0)
}

# accept

Accept a pending connection on a listening socket and return a new connected socket handle. The new handle is used for communication with that specific client while the original listening socket continues accepting others. Returns the packed remote address on success, false on failure.

listen($srv, 5)
while (my $remote = accept(my $client, $srv)) {
    my ($port, $ip) = sockaddr_in($remote)
    p "connection from " . inet_ntoa($ip) . ":$port"
    send($client, "welcome\n", 0)
}

# connect

Initiate a connection from a socket to a remote address. For TCP sockets this performs the three-way handshake; for UDP it sets the default destination so subsequent send calls do not need an address. Dies or returns false if the connection is refused or times out.

socket(my $sock, AF_INET, SOCK_STREAM, 0)
my $addr = sockaddr_in(80, inet_aton("example.com"))
connect($sock, $addr) or die "connect: $!"
send($sock, "GET / HTTP/1.0\r\n\r\n", 0)
recv($sock, my $buf, 4096, 0)
p $buf

# send

Send data through a connected socket. The flags argument controls behavior — use 0 for normal sends. For UDP sockets you can supply a destination address as a fourth argument to send to a specific peer without calling connect first. Returns the number of bytes sent, or undef on error.

send($sock, "hello world\n", 0)
my $n = send($sock, $payload, 0)
p "sent $n bytes"
# UDP to specific peer
send($udp, $msg, 0, sockaddr_in(5000, inet_aton("10.0.0.1")))

# recv

Receive data from a socket into a buffer. The length argument specifies the maximum number of bytes to read. For stream sockets a short read is normal — loop until you have all expected data. For datagram sockets each call returns exactly one datagram. Returns the sender address for UDP, or empty string for TCP.

recv($sock, my $buf, 4096, 0) or die "recv: $!"
p $buf
my $data = ""
while (recv($sock, my $chunk, 8192, 0) && length($chunk)) {
    $data .= $chunk
}

# shutdown

Shut down part or all of a socket connection without closing the file descriptor. The how argument controls direction: 0 stops reading, 1 stops writing (sends FIN to peer), 2 stops both. This is useful for signaling end-of-data to the remote side while still reading its response.

send($sock, $request, 0)
shutdown($sock, 1)           # done writing
recv($sock, my $resp, 65536, 0)  # still read response
shutdown($sock, 2)           # fully close

# setsockopt

Set an option on a socket at the specified protocol level. Common uses include enabling SO_REUSEADDR to allow immediate rebinding after a server restart, setting TCP_NODELAY to disable Nagle's algorithm, or adjusting buffer sizes. The value is typically a packed integer.

setsockopt($srv, SOL_SOCKET, SO_REUSEADDR, 1)
setsockopt($sock, IPPROTO_TCP, TCP_NODELAY, 1)
setsockopt($sock, SOL_SOCKET, SO_RCVBUF, pack("I", 262144))

# getsockopt

Retrieve the current value of a socket option at the specified protocol level. Returns the option value as a packed binary string — use unpack to interpret it. Useful for inspecting buffer sizes, checking whether SO_REUSEADDR is set, or reading OS-assigned values.

my $val = getsockopt($sock, SOL_SOCKET, SO_RCVBUF)
p unpack("I", $val)                 # e.g. 131072
my $reuse = getsockopt($srv, SOL_SOCKET, SO_REUSEADDR)
p unpack("I", $reuse)               # 1 or 0

# getsockname

Return the packed socket address of the local end of a socket. This is useful when the socket was bound to INADDR_ANY or port 0 (OS-assigned) and you need to discover the actual address and port the OS chose. Unpack the result with sockaddr_in.

bind($sock, sockaddr_in(0, INADDR_ANY))  # OS picks port
my $local = getsockname($sock)
my ($port, $ip) = sockaddr_in($local)
p "listening on port $port"

# getpeername

Return the packed socket address of the remote end of a connected socket. Use sockaddr_in or sockaddr_in6 to unpack it into a port and IP address. This is how a server discovers which client it is talking to after accept, or how a client confirms the peer address after connect.

my $packed = getpeername($client)
my ($port, $ip) = sockaddr_in($packed)
p "peer: " . inet_ntoa($ip) . ":$port"

# gethostbyname

Resolve a hostname to its network addresses using the system resolver. Returns ($name, $aliases, $addrtype, $length, @addrs). The addresses are packed binary — pass them through inet_ntoa to get dotted-quad strings. This is the classic DNS forward-lookup function.

my @info = gethostbyname("example.com")
my @addrs = @info[4..$ #info]
@addrs |> map inet_ntoa |> e p
my $ip = inet_ntoa((gethostbyname("localhost"))[4])
p $ip   # 127.0.0.1

# gethostbyaddr

Perform a reverse DNS lookup — given a packed binary IP address and address family, return the hostname associated with that address. Returns ($name, $aliases, $addrtype, $length, @addrs) on success, or empty list if no PTR record exists.

my $packed = inet_aton("8.8.8.8")
my $name = (gethostbyaddr($packed, AF_INET))[0]
p $name   # dns.google

# getprotobyname

Look up a network protocol by its name and return protocol information. Returns ($name, $aliases, $proto_number). The protocol number is what you pass to socket as the protocol argument. Common names include tcp, udp, and icmp.

my ($name, $aliases, $proto) = getprotobyname("tcp")
p "$name = protocol $proto"   # tcp = protocol 6
socket(my $raw, AF_INET, SOCK_RAW, (getprotobyname("icmp"))[2])

# getservbyname

Look up a network service by its name and protocol, returning the port number and related information. Returns ($name, $aliases, $port, $proto). The port is in host byte order. This resolves well-known service names like http, ssh, or smtp to their port numbers portably.

my ($name, $aliases, $port) = getservbyname("http", "tcp")
p "$name => port $port"         # http => port 80
my $ssh_port = (getservbyname("ssh", "tcp"))[2]
p $ssh_port                     # 22

# sha256

sha256 (alias s256) computes the SHA-256 cryptographic hash of the input data and returns it as a 64-character lowercase hexadecimal string. SHA-256 is the most widely used hash function for data integrity verification, content addressing, and digital signatures. The Rust implementation is significantly faster than pure-Perl alternatives. Accepts strings or byte buffers.

p sha256 "hello world"   # b94d27b9934d3e08...
my $checksum = sha256 slurp "release.tar.gz"
p $checksum
rl("passwords.txt") |> map sha256 |> e p

# sha224

sha224 (alias s224) computes the SHA-224 cryptographic hash and returns a 56-character hex string. SHA-224 is a truncated variant of SHA-256 that produces a shorter digest while maintaining strong collision resistance. It is sometimes preferred when storage or bandwidth for the hash value is constrained, such as in compact data structures or short identifiers.

p sha224 "hello world"   # 2f05477fc24bb4fa...
my $h = sha224(tj {key => "value"})
p $h

# sha384

sha384 (alias s384) computes the SHA-384 cryptographic hash and returns a 96-character hex string. SHA-384 is a truncated variant of SHA-512 that offers a middle ground between SHA-256 and SHA-512 in both digest length and security margin. It is commonly used in TLS certificate fingerprints and government security standards that require larger-than-256-bit digests.

p sha384 "hello world"   # fdbd8e75a67f29f7...
my $sig = sha384(slurp "document.pdf")
spurt "document.pdf.sha384", $sig

# sha512

sha512 (alias s512) computes the SHA-512 cryptographic hash and returns a 128-character hex string. SHA-512 provides the largest digest size in the SHA-2 family and is the strongest option when maximum collision resistance is needed. On 64-bit systems, SHA-512 is often faster than SHA-256 because it operates on 64-bit words natively. Use this for high-security applications or when you need a longer hash.

p sha512 "hello world"   # 309ecc489c12d6eb...
my $hash = sha512(slurp "firmware.bin");
p $hash;
my @hashes = map { sha512 } @files

# sha1

sha1 (alias s1) computes the SHA-1 hash and returns a 40-character hex string. SHA-1 is considered cryptographically broken for collision resistance and should not be used for security-sensitive applications. However, it remains widely used for non-security purposes such as Git object IDs, cache keys, and deduplication checksums where collision attacks are not a concern.

p sha1 "hello world"   # 2aae6c35c94fcfb4...
my $git_id = sha1("blob " . length($content) . "\0" . $content)
p $git_id$1

Note: prefer SHA-256 for any security-related use case.

# crc32

crc32 computes the CRC-32 checksum of the input data and returns it as an unsigned 32-bit integer. CRC-32 is not a cryptographic hash — it is a fast error-detection code used in network protocols (Ethernet, ZIP, PNG), file integrity checks, and hash table bucketing. It is extremely fast compared to SHA functions, making it suitable for high-throughput deduplication or quick change detection where collision resistance is not required.

p crc32 "hello world"   # 222957957
my $chk = crc32(slurp "archive.zip");
p sprintf "0x%08x", $chk;  # hex representation
my @checksums = map { crc32 } @chunks

# hmac_sha256

hmac_sha256 (alias hmac) computes an HMAC-SHA256 message authentication code using the given data and secret key, returning a hex string. HMAC combines a cryptographic hash with a secret key to produce a signature that verifies both data integrity and authenticity. This is the standard mechanism for signing API requests (AWS, Stripe, GitHub webhooks), generating secure tokens, and verifying message authenticity.

my $sig = hmac_sha256 "request body", "my-secret-key"
p $sig
my $webhook_sig = hmac("POST /hook\n$body", $secret)
p $webhook_sig eq $expected ? "valid" : "tampered"

# blake2b

blake2b (alias b2b) computes the BLAKE2b-512 cryptographic hash and returns a 128-character hex string. BLAKE2b is faster than SHA-256 while being at least as secure. It is used in Argon2 password hashing, libsodium, WireGuard, and many modern cryptographic protocols. Prefer BLAKE2b or BLAKE3 for new projects over SHA-256.

p blake2b "hello world"   # 021ced8799...
my $hash = b2b(slurp "large-file.bin");
my @hashes = map { blake2b } @messages

# blake2s

blake2s (alias b2s) computes the BLAKE2s-256 cryptographic hash and returns a 64-character hex string. BLAKE2s is optimized for 8-32 bit platforms while BLAKE2b targets 64-bit. Use BLAKE2s when targeting embedded systems, WebAssembly, or when a 256-bit digest suffices.

p blake2s "hello world"   # 9aec6806...
my $checksum = b2s($firmware_blob)

# blake3

blake3 (alias b3) computes the BLAKE3 cryptographic hash and returns a 64-character hex string (256-bit). BLAKE3 is the latest evolution — it is parallelizable, even faster than BLAKE2, and suitable for hashing large files at maximum speed. It is the recommended hash function for new projects where legacy compatibility is not required.

p blake3 "hello world"   # d74981efa...
my $hash = b3(slurp "gigabyte-file.bin")  # fast!

# argon2_hash

argon2_hash (alias argon2) hashes a password using Argon2id, the winner of the Password Hashing Competition. Returns a PHC-format string containing algorithm parameters, salt, and hash. Argon2 is memory-hard and resistant to GPU/ASIC attacks. Use this for user password storage — never use MD5/SHA for passwords.

my $hash = argon2_hash("user-password")
to_file("user.hash", $hash)
# later...
if (argon2_verify("user-password", $hash)) {
    p "login successful"
}

# argon2_verify

argon2_verify verifies a password against an Argon2 PHC hash string. Returns 1 if the password matches, 0 otherwise. The verification automatically extracts parameters from the stored hash, so changing Argon2 settings for new hashes does not break existing ones.

my $stored = rl("user.hash")
if (argon2_verify($user_input, $stored)) {
    p "access granted"
} else {
    p "invalid password"
}

# bcrypt_hash

bcrypt_hash (alias bcrypt) hashes a password using the bcrypt algorithm, returning a standard $2b$... format string. Bcrypt has been the industry standard for password hashing for over 20 years. While Argon2 is now preferred for new systems, bcrypt remains secure and widely deployed.

my $hash = bcrypt_hash("my-password")
p $hash  # $2b$12$...
if (bcrypt_verify("my-password", $hash)) {
    p "correct"
}

# bcrypt_verify

bcrypt_verify verifies a password against a bcrypt hash string. Returns 1 if correct, 0 otherwise. The cost factor and salt are extracted from the stored hash automatically.

if (bcrypt_verify($password, $stored_hash)) {
    grant_access()
}

# scrypt_hash

scrypt_hash (alias scrypt) hashes a password using the scrypt algorithm, returning a PHC-format string. Scrypt is memory-hard like Argon2 and is used in cryptocurrency (Litecoin) and some enterprise systems. It predates Argon2 but remains secure.

my $hash = scrypt_hash("password123")
if (scrypt_verify("password123", $hash)) {
    p "verified"
}

# scrypt_verify

scrypt_verify verifies a password against a scrypt PHC hash. Returns 1 on match, 0 otherwise.

if (scrypt_verify($input, $stored)) {
    p "valid"
}

# pbkdf2

pbkdf2 (alias pbkdf2_derive) derives a cryptographic key from a password using PBKDF2-HMAC-SHA256. Returns a 64-character hex string (32 bytes). Takes password, salt, and optional iteration count (default 100,000). Use this when you need a fixed-length key from a password — for encryption keys, not password storage (use Argon2/bcrypt for that).

my $key = pbkdf2("password", "random-salt")
p $key  # 64 hex chars = 32 bytes
my $strong = pbkdf2("pass", $salt, 200_000)  # more iterations

# random_bytes

random_bytes (alias randbytes) generates cryptographically secure random bytes using the OS CSPRNG. Returns a byte buffer of the specified length. Use for encryption keys, nonces, salts, and any security-sensitive randomness. Never use rand() for cryptographic purposes.

my $key = random_bytes(32)   # 256-bit key
my $nonce = random_bytes(12) # 96-bit nonce for AES-GCM
p hex_encode($key)

# random_bytes_hex

random_bytes_hex (alias randhex) generates cryptographically secure random bytes and returns them as a hex string. Convenient when you need a random hex token or key without a separate hex_encode call.

my $token = random_bytes_hex(16)  # 32 hex chars
p $token   # 7a3f9b2c1d...
my $api_key = "sk_" . randhex(24)

# aes_encrypt

aes_encrypt (alias aes_enc) encrypts plaintext using AES-256-GCM authenticated encryption. Takes a 32-byte key (use random_bytes(32) or pbkdf2). Returns a base64 string containing the nonce and ciphertext. AES-GCM provides both confidentiality and integrity — tampering is detected on decryption.

my $key = random_bytes(32)
my $cipher = aes_encrypt($key, "secret message")
p $cipher  # base64 encoded
my $plain = aes_decrypt($key, $cipher)
p $plain   # secret message

# aes_decrypt

aes_decrypt (alias aes_dec) decrypts AES-256-GCM ciphertext produced by aes_encrypt. Takes the same 32-byte key and the base64 ciphertext. Dies if the key is wrong or the ciphertext was tampered with (authentication failure).

my $plain = aes_decrypt($key, $ciphertext)
p $plain
# wrong key or tampered data raises exception

# chacha_encrypt

chacha_encrypt (alias chacha_enc) encrypts plaintext using ChaCha20-Poly1305 authenticated encryption. Takes a 32-byte key. Returns base64(nonce || ciphertext || tag). ChaCha20-Poly1305 is the modern alternative to AES-GCM — faster in software, constant-time, and used in TLS 1.3, WireGuard, and SSH.

my $key = random_bytes(32)
my $cipher = chacha_encrypt($key, "secret data")
my $plain = chacha_decrypt($key, $cipher)
p $plain

# chacha_decrypt

chacha_decrypt (alias chacha_dec) decrypts ChaCha20-Poly1305 ciphertext. Takes the same 32-byte key and base64 ciphertext. Dies on wrong key or tampering.

my $plain = chacha_decrypt($key, $cipher)
p $plain

# ed25519_keygen

ed25519_keygen (alias ed_keygen) generates an Ed25519 signing keypair. Returns [private_key_hex, public_key_hex]. Ed25519 is the modern standard for digital signatures — fast, secure, and used in SSH, GPG, and cryptocurrency. The private key is 32 bytes (64 hex), the public key is also 32 bytes.

my ($priv, $pub) = @{ ed25519_keygen() }
p "Private: $priv"
p "Public:  $pub"
my $sig = ed25519_sign($priv, "message")

# ed25519_sign

ed25519_sign (alias ed_sign) signs a message with an Ed25519 private key. Takes the private key (hex) and message. Returns a 128-character hex signature (64 bytes). Signatures are deterministic — the same key+message always produces the same signature.

my $sig = ed25519_sign($private_key, "hello world")
p $sig   # 128 hex chars

# ed25519_verify

ed25519_verify (alias ed_verify) verifies an Ed25519 signature. Takes public_key_hex, message, signature_hex. Returns 1 if valid, 0 if invalid. Never trust unsigned data in security contexts.

if (ed25519_verify($pub, "hello world", $sig)) {
    p "signature valid"
} else {
    p "FORGED!"
}

# x25519_keygen

x25519_keygen (alias x_keygen) generates an X25519 key-exchange keypair. Returns [private_key_hex, public_key_hex]. X25519 is the modern Diffie-Hellman — used in TLS 1.3, Signal, WireGuard. Both parties generate keypairs and exchange public keys to derive a shared secret.

my ($my_priv, $my_pub) = @{ x25519_keygen() }
# send $my_pub to peer, receive $their_pub
my $shared = x25519_dh($my_priv, $their_pub)

# x25519_dh

x25519_dh (alias x_dh) performs X25519 Diffie-Hellman key exchange. Takes your private key and their public key. Returns a 64-character hex shared secret. Both parties derive the same secret, which can be used as an encryption key.

my $shared = x25519_dh($my_private, $their_public)
my $key = hex_decode(substr($shared, 0, 64))  # use as AES key

# base64_encode

base64_encode (alias b64e) encodes a string or byte buffer as a Base64 string using the standard alphabet (A-Z, a-z, 0-9, +, /). Base64 is the standard way to embed binary data in text-based formats like JSON, XML, email (MIME), and data URIs. The output length is always a multiple of 4, padded with = as needed. Use base64_decode to reverse the encoding.

my $encoded = base64_encode "hello world"
p $encoded   # aGVsbG8gd29ybGQ=
my $img_data = slurp "photo.png"
my $data_uri = "data:image/png;base64," . base64_encode($img_data)
p base64_decode(base64_encode("round trip"))  # round trip

# base64_decode

base64_decode (alias b64d) decodes a Base64-encoded string back to its original bytes. It accepts standard Base64 with padding and is tolerant of line breaks within the input. This is essential for processing email attachments, decoding JWT payloads, extracting embedded images from data URIs, or reading any Base64-encoded field from an API response. Raises an exception on invalid Base64 input.

my $decoded = base64_decode "aGVsbG8gd29ybGQ="
p $decoded   # hello world
my $img = base64_decode($api_response->{avatar_b64})
spurt "avatar.png", $img
my $json = base64_decode($jwt_parts[1])
dd json_decode $json

# hex_encode

hex_encode (alias hxe) converts a string or byte buffer into its lowercase hexadecimal representation, with two hex characters per input byte. This is useful for displaying binary data in a human-readable format, generating hex-encoded keys or IDs, logging raw bytes, or preparing data for protocols that use hex encoding. The output is always an even number of characters.

p hex_encode "hello"   # 68656c6c6f
my $raw = slurp "key.bin"
p hex_encode $raw
my $color = hex_encode chr(255) . chr(128) . chr(0)
p "#$color"   # #ff8000

# hex_decode

hex_decode (alias hxd) converts a hexadecimal string back to its original bytes, interpreting every two hex characters as one byte. This is the inverse of hex_encode and is useful for parsing hex-encoded binary data from config files, network protocols, or cryptographic outputs. The input must have an even number of valid hex characters (0-9, a-f, A-F) or an exception is raised.

my $bytes = hex_decode "68656c6c6f"
p $bytes   # hello
my $key = hex_decode $env_hex_key
my $mac = hmac_sha256($data, hex_decode($secret_hex))
p hex_decode(hex_encode("round trip"))  # round trip

# hide

hide(CARRIER, SECRET [, KEY]) — polymorphic steganography. Embeds SECRET inside CARRIER and returns the modified carrier. Carrier kind is detected from the input bytes: data starting with the PNG magic (\x89PNG) uses LSB embedding on the R/G/B channels (alpha skipped so transparent pixels can't leak); anything else is treated as text and SECRET bits are encoded as zero-width chars (U+200B for 0, U+200C for 1) inserted between visible characters. Optional KEY enables SHA-256(key||counter)-derived XOR masking of the secret prior to embedding.

Wire format (so reveal knows where to stop): [4-byte BE length][secret bytes][4-byte BE CRC32-IEEE]. A CRC mismatch on reveal means the carrier was re-encoded, truncated, or never contained a payload.

# Text carrier — invisible in rendered output, survives copy-paste in most channels.
my $stego = hide("Lorem ipsum dolor sit amet " x 6, "secret message")
reveal($stego) eq "secret message"   # 1

# PNG carrier — LSB embed survives a re-save through any lossless tool.
"carrier.png" |> slurp |> hide("hidden data") |> spew("out.png")
slurp("out.png") |> reveal |> p     # hidden data

# Key-XOR mode — wrong key still passes CRC but recovers garbage.
hide($png_bytes, $secret, "shared-passphrase") |> spew("out.png")
reveal(slurp("out.png"), "shared-passphrase")

World-first: no other major scripting language ships polymorphic steganography (text + image) as a single first-class builtin. Python needs stegano + stegcloak, Perl needs Image::PNG::Libpng + hand-rolled bit twiddling.

See also: reveal, hide_capacity.

# reveal

reveal(STEGO [, KEY]) — extract the secret embedded by hide. Auto-detects carrier kind the same way hide does (PNG magic vs text). Returns raw bytes; wrap with decode_utf8(...) if you know the secret is text.

Errors with a corrupt or absent payload message on:

• CRC32 mismatch (carrier re-encoded by a lossy tool, or no payload was ever embedded)
• declared length exceeding the carrier's embedded bit capacity
• carrier too small to even hold a 4-byte length prefix

my $secret = reveal($stego)                  # bytes
p $secret                                    # auto-stringifies via UTF-8 decode

my $hidden = slurp("image.png") |> reveal
my $keyed  = reveal($stego, "shared-passphrase")

# Detect tampering: anything that mutates the embedded bits fails the CRC32.
try { reveal($maybe_stego) } catch ($e) {
    warn "no valid payload: $e"
}

See also: hide, hide_capacity.

# hide_capacity

hide_capacity(CARRIER) — return how many bytes of secret payload CARRIER can hold, accounting for the 8-byte envelope overhead (4-byte length + 4-byte CRC32). Useful for sizing before calling hide.

For PNG carriers: (width * height * 3) / 8 - 8 (R+G+B LSBs, alpha skipped). For text carriers: (visible_chars / 8) - 8 (one bit per visible code point).

my $cap = hide_capacity(slurp("carrier.png"))
p "can hide up to $cap bytes"
if (length($secret) > $cap) {
    die "secret too large for this carrier"
}
hide_capacity("x" x 100)   # 4

See also: hide, reveal.

# uuid

uuid generates a cryptographically random UUID version 4 string in the standard 8-4-4-4-12 hyphenated format. Each call produces a unique identifier suitable for database primary keys, correlation IDs, session tokens, temporary file names, or any situation requiring a globally unique identifier without coordination. The randomness comes from the OS CSPRNG.

my $id = uuid()
p $id   # e.g., 550e8400-e29b-41d4-a716-446655440000
my %record = (id => uuid(), name => "Alice", created => time)
my @ids = map { uuid() } 1:10

# jwt_encode

jwt_encode creates a signed JSON Web Token from a payload hashref and a secret key. The default algorithm is HS256 (HMAC-SHA256), but you can specify an alternative as the third argument. JWTs are the standard for stateless authentication tokens, API authorization, and secure inter-service communication. The returned string contains the base64url-encoded header, payload, and signature separated by dots.

my $token = jwt_encode({sub => "user123", exp => time + 3600}, "my-secret")
p $token
my $admin = jwt_encode({role => "admin", iat => time}, $secret, "HS512")
# send as Authorization header
http_request(method => "GET", url => $api_url,
    headers => {Authorization => "Bearer $token"})

# jwt_decode

jwt_decode verifies the signature of a JSON Web Token using the provided secret key and returns the decoded payload as a hashref. If the signature is invalid, the token has been tampered with, or it has expired (when an exp claim is present), the function raises an exception. This is the secure way to validate incoming JWTs from clients or other services — always use this over jwt_decode_unsafe in production.

my $payload = jwt_decode($token, "my-secret")
p $payload->{sub}   # user123
my $claims = jwt_decode($bearer_token, $secret)
if ($claims->{role} eq "admin") {
    p "admin access granted"
}

Note: raises an exception on expired tokens, invalid signatures, or malformed input.

# jwt_decode_unsafe

jwt_decode_unsafe decodes a JSON Web Token and returns the payload as a hashref without verifying the signature. This is intentionally insecure and should only be used for debugging, logging, or inspecting token contents in development environments. Never use this to make authorization decisions in production — an attacker can stryke arbitrary payloads. The function still parses the JWT structure and base64-decodes the payload, but skips all cryptographic checks.

# debugging only — never use for auth
my $claims = jwt_decode_unsafe($token)
dd $claims
p $claims->{sub}   # inspect without needing the secret
my $exp = $claims->{exp}
p "Expires: " . datetime_from_epoch($exp)$1

Note: this function exists for debugging. Use `jwt_decode` with a secret for any security-relevant validation.

# url_encode

Percent-encode a string so it is safe to embed in a URL query parameter or path segment. Unreserved characters (alphanumeric, -, _, ., ~) are left as-is; everything else becomes %XX. The alias uri_escape matches the classic URI::Escape name for Perl muscle-memory.

my $q = "hello world & friends"
my $safe = url_encode($q)
p $safe   # hello%20world%20%26%20friends
my $url = "https://example.com/search?q=" . url_encode($q)
p $url$1

Note: does not encode the full URL structure — encode individual components, not the whole URL.

# url_decode

Decode a percent-encoded string back to its original form, converting %XX sequences to the corresponding bytes and + to space. The alias uri_unescape matches URI::Escape conventions. Use this when parsing query strings from incoming URLs or reading URL-encoded form data.

my $encoded = "hello%20world%20%26%20friends"
p url_decode($encoded)   # hello world & friends
# round-trip
my $orig = "café ☕"
p url_decode(url_encode($orig)) eq $orig  # 1

# gzip

Compress a string or byte buffer using the gzip (RFC 1952) format and return the compressed bytes. Useful for shrinking data before writing to disk or sending over the network. Pairs with gunzip for decompression. The compression level is chosen automatically for a good speed/size tradeoff.

my $raw = "hello world" x 1000
my $gz = gzip($raw)
to_file("data.gz", $gz)
p length($gz)       # much smaller than original
p gunzip($gz) eq $raw  # 1

# gunzip

Decompress gzip-compressed data (RFC 1952) and return the original bytes. Dies if the input is not valid gzip. Use this to read .gz files or decompress data received from HTTP responses with Content-Encoding: gzip. Always the inverse of gzip.

my $compressed = rl("archive.gz")
my $text = gunzip($compressed)
p $text
# round-trip in a pipeline
"payload" |> gzip |> gunzip |> p  # payload

# zstd

Compress a string or byte buffer using the Zstandard algorithm and return the compressed bytes. Zstandard offers significantly better compression ratios and speed compared to gzip, making it ideal for large datasets, IPC buffers, and caching. Pairs with zstd_decode for decompression.

my $big = "x]" x 100_000
my $compressed = zstd($big)
p length($compressed)  # fraction of original
to_file("data.zst", $compressed)
p zstd_decode($compressed) eq $big  # 1

# zstd_decode

Decompress Zstandard-compressed data and return the original bytes. Dies if the input is not valid Zstandard. This is the inverse of zstd. Use it to read .zst files or decompress cached buffers that were compressed with zstd.

my $packed = zstd("important data\n" x 500)
my $original = zstd_decode($packed)
p $original
# file round-trip
to_file("cache.zst", zstd($payload))
p zstd_decode(rl("cache.zst"))

# sha3_256

sha3_256 (alias s3_256) computes the SHA3-256 hash (NIST FIPS 202) and returns a 64-character hex string. SHA-3 is the newest NIST-approved hash family, designed as a backup if SHA-2 is ever compromised. It uses the Keccak sponge construction which is fundamentally different from SHA-2.

p sha3_256 "hello world"   # 644bcc7e...
my $h = s3_256(slurp "file.bin")

# sha3_512

sha3_512 (alias s3_512) computes the SHA3-512 hash and returns a 128-character hex string. Provides a 512-bit digest with the SHA-3 sponge construction.

p sha3_512 "hello world"   # 840006...

# shake128

shake128 is a SHA-3 extendable-output function (XOF). Unlike fixed-length hashes, SHAKE can produce arbitrary-length output. Takes data and output length in bytes, returns hex. Useful for key derivation or when you need a variable-length digest.

p shake128("seed", 32)   # 64 hex chars (32 bytes)
p shake128("seed", 64)   # 128 hex chars

# shake256

shake256 is a SHA-3 XOF with higher security margin than SHAKE128. Takes data and output length in bytes, returns hex.

p shake256("seed", 32)
p shake256("key material", 64)

# ripemd160

ripemd160 (alias rmd160) computes the RIPEMD-160 hash and returns a 40-character hex string. RIPEMD-160 is used in Bitcoin addresses (Hash160 = RIPEMD160(SHA256(pubkey))) and some legacy systems. Not recommended for new designs but essential for Bitcoin/crypto compatibility.

p ripemd160 "hello world"   # 98c615784c...
my $hash160 = ripemd160(hex_decode(sha256($pubkey)))

# siphash

siphash computes SipHash-2-4 with default keys (0,0) and returns a 16-character hex string (64-bit). SipHash is designed for hash table DoS resistance — it's fast and keyed, preventing attackers from crafting collisions. Used in Rust's HashMap, Python dict, and many other hash tables.

p siphash "key"   # 16 hex chars

# hmac_sha1

hmac_sha1 computes HMAC-SHA1 and returns a 40-character hex string. Used in OAuth 1.0, TOTP (Google Authenticator), and legacy APIs. Prefer HMAC-SHA256 for new designs.

p hmac_sha1("secret", "message")   # 40 hex chars

# hmac_sha384

hmac_sha384 computes HMAC-SHA384 and returns a 96-character hex string. Middle ground between SHA-256 and SHA-512.

p hmac_sha384("key", "data")   # 96 hex chars

# hmac_sha512

hmac_sha512 computes HMAC-SHA512 and returns a 128-character hex string. Maximum security margin in the SHA-2 family.

p hmac_sha512("key", "data")   # 128 hex chars

# hmac_md5

hmac_md5 computes HMAC-MD5 and returns a 32-character hex string. Legacy only — MD5 is broken for collision resistance but HMAC-MD5 is still considered safe for authentication. Only use for compatibility with old systems.

p hmac_md5("key", "data")   # 32 hex chars

# hkdf_sha256

hkdf_sha256 (alias hkdf) is HKDF key derivation (RFC 5869) using HMAC-SHA256. Extracts entropy from input key material and expands it to the desired length. Used to derive encryption keys from shared secrets (after ECDH/X25519). Args: ikm, salt, info, output_length.

my $key = hkdf("shared_secret", "salt", "context", 32)  # 64 hex
my $enc_key = hex_decode($key)  # 32 bytes for AES-256

# hkdf_sha512

hkdf_sha512 is HKDF using HMAC-SHA512. Higher security margin than SHA256 variant.

my $key = hkdf_sha512("ikm", "salt", "info", 64)  # 128 hex chars

# poly1305

poly1305 computes a Poly1305 one-time MAC. Takes a 32-byte key and message, returns a 32-character hex tag (128-bit). Poly1305 is used with ChaCha20 in TLS 1.3. CRITICAL: each key must only be used once — reusing a key completely breaks security.

my $key = random_bytes(32)
p poly1305($key, "message")   # 32 hex chars

# rsa_keygen

rsa_keygen generates an RSA keypair. Takes key size in bits (2048, 3072, or 4096). Returns [private_key_pem, public_key_pem]. RSA is the most widely used asymmetric algorithm — essential for TLS, SSH, and JWT RS256 signing.

my @kp = rsa_keygen(2048)
my ($priv, $pub) = @kp
spurt("private.pem", $priv)
spurt("public.pem", $pub)

# rsa_encrypt

rsa_encrypt (alias rsa_enc) encrypts data with RSA-OAEP-SHA256. Takes public_key_pem and plaintext. Returns base64 ciphertext. Message size is limited to key_size/8 - 66 bytes (e.g. 190 bytes for 2048-bit key).

my $cipher = rsa_encrypt($pub_pem, "secret")
my $plain = rsa_decrypt($priv_pem, $cipher)

# rsa_decrypt

rsa_decrypt (alias rsa_dec) decrypts RSA-OAEP ciphertext. Takes private_key_pem and base64 ciphertext.

my $plain = rsa_decrypt($priv, $ciphertext)
p $plain

# rsa_sign

rsa_sign signs a message with RSA-PKCS1v15-SHA256. Takes private_key_pem and message. Returns base64 signature. This is the RS256 algorithm used in JWT.

my $sig = rsa_sign($priv, "message")
if (rsa_verify($pub, "message", $sig)) {
    p "valid"
}

# rsa_verify

rsa_verify verifies an RSA-PKCS1v15-SHA256 signature. Takes public_key_pem, message, and base64 signature. Returns 1 if valid, 0 if not.

if (rsa_verify($pub_pem, $msg, $sig)) {
    p "signature valid"
}

# ecdsa_p256_keygen

ecdsa_p256_keygen (alias p256_keygen) generates an ECDSA P-256 (secp256r1/prime256v1) keypair. Returns [private_hex, public_hex_compressed]. P-256 is the NIST curve used in TLS, ES256 JWT, and WebAuthn.

my @kp = ecdsa_p256_keygen()
my ($priv, $pub) = @kp

# ecdsa_p256_sign

ecdsa_p256_sign (alias p256_sign) signs a message with ECDSA P-256. Takes private_key_hex and message. Returns DER-encoded signature as hex.

my $sig = ecdsa_p256_sign($priv, "hello")

# ecdsa_p256_verify

ecdsa_p256_verify (alias p256_verify) verifies an ECDSA P-256 signature. Returns 1 if valid.

if (ecdsa_p256_verify($pub, "hello", $sig)) {
    p "valid"
}

# ecdsa_p384_keygen

ecdsa_p384_keygen generates an ECDSA P-384 keypair. P-384 offers more security margin than P-256.

my @kp = ecdsa_p384_keygen()

# ecdsa_p384_sign

ecdsa_p384_sign signs with ECDSA P-384.

my $sig = ecdsa_p384_sign($priv, $msg)

# ecdsa_p384_verify

ecdsa_p384_verify verifies an ECDSA P-384 signature.

p ecdsa_p384_verify($pub, $msg, $sig)

# ecdsa_secp256k1_keygen

ecdsa_secp256k1_keygen generates an ECDSA secp256k1 keypair. This is the Bitcoin/Ethereum curve — different from P-256.

my @kp = ecdsa_secp256k1_keygen()

# ecdsa_secp256k1_sign

ecdsa_secp256k1_sign signs with ECDSA secp256k1.

my $sig = ecdsa_secp256k1_sign($priv, $msg)

# ecdsa_secp256k1_verify

ecdsa_secp256k1_verify verifies an ECDSA secp256k1 signature.

p ecdsa_secp256k1_verify($pub, $msg, $sig)

# ecdh_p256

ecdh_p256 (alias p256_dh) performs ECDH key exchange on P-256. Takes my_private_hex and their_public_hex, returns shared_secret_hex. Use HKDF to derive encryption keys from the shared secret.

my @alice = ecdsa_p256_keygen()
my @bob = ecdsa_p256_keygen()
my $shared_a = ecdh_p256($alice[0], $bob[1])
my $shared_b = ecdh_p256($bob[0], $alice[1])
p $shared_a eq $shared_b  # 1 — same secret

# ecdh_p384

ecdh_p384 performs ECDH key exchange on P-384.

my $shared = ecdh_p384($my_priv, $their_pub)

# base32_encode

base32_encode (alias b32e) encodes data as RFC 4648 Base32. Used in TOTP secrets, onion addresses, and Bech32. Returns uppercase with padding.

p base32_encode("hello")   # NBSWY3DP
my $secret = base32_encode(random_bytes(20))

# base32_decode

base32_decode (alias b32d) decodes RFC 4648 Base32 back to bytes. Accepts with or without padding.

p base32_decode("NBSWY3DP")   # hello

# base58_encode

base58_encode (alias b58e) encodes data using Bitcoin's Base58 alphabet (no 0, O, I, l to avoid confusion). Used in Bitcoin addresses, IPFS CIDs.

p base58_encode("hello")   # Cn8eVZg

# base58_decode

base58_decode (alias b58d) decodes Base58 back to bytes.

p base58_decode("Cn8eVZg")   # hello

# totp

totp (alias totp_generate) generates a TOTP code (RFC 6238) for 2FA. Takes base32-encoded secret, optional digits (default 6), optional period (default 30s). Compatible with Google Authenticator, Authy, etc.

my $secret = base32_encode(random_bytes(20))
my $code = totp($secret)
p $code   # 6-digit code
# Custom: 8 digits, 60s period
my $code8 = totp($secret, 8, 60)

# totp_verify

totp_verify verifies a TOTP code with optional time window (default ±1 period). Returns 1 if valid.

if (totp_verify($secret, $user_code)) {
    p "2FA valid"
}
# Wider window: ±2 periods
totp_verify($secret, $code, 2)

# hotp

hotp (alias hotp_generate) generates an HOTP code (RFC 4226) using a counter. Takes base32 secret, counter value, optional digits.

my $code = hotp($secret, 42)  # counter=42

# aes_cbc_encrypt

aes_cbc_encrypt (alias aes_cbc_enc) encrypts with AES-256-CBC and PKCS7 padding. Takes 32-byte key, plaintext, optional 16-byte IV (auto-generated if omitted). Returns base64(iv || ciphertext). Legacy mode — prefer aes_encrypt (GCM) for new code.

my $key = random_bytes(32)
my $ct = aes_cbc_encrypt($key, "secret")
my $pt = aes_cbc_decrypt($key, $ct)

# aes_cbc_decrypt

aes_cbc_decrypt (alias aes_cbc_dec) decrypts AES-256-CBC. Takes 32-byte key and base64(iv || ciphertext).

my $pt = aes_cbc_decrypt($key, $ciphertext)

# qr_ascii

qr_ascii (alias qr) generates a QR code as ASCII art. Perfect for terminal output.

p qr("https://example.com")
p qr("otpauth://totp/App:user?secret=$secret&issuer=App")

# qr_png

qr_png generates a QR code as PNG image data (base64 encoded). Optional size parameter. Save to file or embed in HTML.

my $png = qr_png("https://example.com")
spurt("qr.png", base64_decode($png))
# Larger QR
my $big = qr_png($url, 16)

# controller

controller([bind, [port]]) — drop this stryke process into controller mode: bind a TCP listener at bind:port, accept agent connections, and run the interactive REPL on stdin so commands like status, @CODE, eval CODE, fire, terminate, and shutdown can be typed at the prompt. Blocking; returns the exit code (0 on a clean shutdown, 1 if bind fails). Defaults: bind="0.0.0.0", port=9999.

Equivalent to the stryke controller CLI subcommand but invokable from any stryke source file. Combine with agent() and spawn to run controller + local agent in a single process for testing.

# Bare invocation — bind 0.0.0.0:9999, REPL on stdin
controller()

# Explicit
exit controller("127.0.0.1", 8888)

# Controller + local agent in one process (testing pattern)
spawn {
    sleep 1
    agent("localhost:9999", "local-worker")
}
controller("127.0.0.1", 9999)

See also: agent.

# agent

agent([controller_addr, [name]]) — drop this stryke process into agent mode: connect to controller_addr (default localhost:9999), send AGENT_HELLO, and enter the persistent frame loop handling FIRE / EVAL / TERMINATE / STATUS / SHUTDOWN from the controller. EVAL frames carry arbitrary stryke source that runs against a persistent per-agent VMHelper, so sub definitions and $main::name globals survive across calls — the controller becomes a remote REPL.

controller_addr may be a bare host (port defaults to 9999) or host:port. name is what shows in the controller's status table — defaults to the local hostname if omitted.

Blocking; returns the exit code (0 clean disconnect, 1 connection or handshake failure). Wrap in spawn { agent(...) } to run an agent in the background.

#!/usr/bin/env stryke
# Become an agent on boot
exit agent($ENV{CONTROLLER_ADDR} // "ctl.local:9999", $ENV{HOSTNAME})

# Multi-agent test fixture in one process
spawn { agent("localhost:9999", "worker-1") }
spawn { agent("localhost:9999", "worker-2") }
controller("127.0.0.1", 9999)

See also: controller.

# qr_svg

qr_svg generates a QR code as SVG string. Scalable vector graphics, ideal for web.

my $svg = qr_svg("https://example.com")
spurt("qr.svg", $svg)

# barcode_code128

barcode_code128 (alias code128) generates a Code 128 barcode as ASCII. Code 128 supports alphanumeric data and is widely used in shipping labels.

p code128("ABC-123")

# barcode_code39

barcode_code39 (alias code39) generates a Code 39 barcode. Supports uppercase, digits, and some symbols. Used in automotive and defense.

p code39("HELLO123")

# barcode_ean13

barcode_ean13 (alias ean13) generates an EAN-13 barcode (European Article Number). Standard retail barcode — requires exactly 12-13 digits.

p ean13("5901234123457")

# barcode_svg

barcode_svg generates a barcode as SVG. Second argument specifies type: code128, code39, ean13, upca.

my $svg = barcode_svg("ABC-123", "code128")
spurt("barcode.svg", $svg)
my $retail = barcode_svg("012345678905", "upca")

# brotli

brotli (alias br) compresses data using the Brotli algorithm (RFC 7932). Excellent compression ratio, used in HTTP compression. Returns compressed bytes.

my $compressed = brotli($data)
p length($data) . " -> " . length($compressed)

# brotli_decode

brotli_decode (alias ubr) decompresses Brotli data.

my $original = brotli_decode($compressed)

# xz

xz (alias lzma) compresses data using XZ/LZMA2. Best compression ratio, slower. Returns compressed bytes.

my $compressed = xz($data)
spurt("file.xz", $compressed)

# xz_decode

xz_decode (aliases unxz, unlzma) decompresses XZ/LZMA data.

my $original = xz_decode(slurp("file.xz"))

# bzip2

bzip2 (alias bz2) compresses data using bzip2. Good compression, moderate speed. Returns compressed bytes.

my $compressed = bzip2($data)

# bzip2_decode

bzip2_decode (aliases bunzip2, ubz2) decompresses bzip2 data.

my $original = bunzip2($compressed)

# lz4

lz4 compresses data using LZ4. Very fast compression/decompression, moderate ratio. Ideal for real-time compression.

my $compressed = lz4($data)

# lz4_decode

lz4_decode (alias unlz4) decompresses LZ4 data.

my $original = lz4_decode($compressed)

# snappy

snappy (alias snp) compresses data using Snappy. Fastest compression, used in databases and RPC. Returns compressed bytes.

my $compressed = snappy($data)

# snappy_decode

snappy_decode (alias unsnappy) decompresses Snappy data.

my $original = snappy_decode($compressed)

# lzw

lzw compresses data using LZW (GIF/TIFF style). Classic algorithm.

my $compressed = lzw($data)

# lzw_decode

lzw_decode (alias unlzw) decompresses LZW data.

my $original = lzw_decode($compressed)

# tar_create

tar_create (alias tar) creates a tar archive from a directory. Returns tar bytes.

my $archive = tar_create("./src")
spurt("backup.tar", $archive)

# tar_extract

tar_extract (alias untar) extracts a tar archive to a directory.

tar_extract(slurp("backup.tar"), "./restored")

# tar_list

tar_list lists files in a tar archive. Returns array of paths.

my @files = @{tar_list(slurp("backup.tar"))}
@files |> e p

# tar_gz_create

tar_gz_create (alias tgz) creates a gzipped tar archive. Convenience for tar + gzip.

my $tgz = tgz("./project")
spurt("project.tar.gz", $tgz)

# tar_gz_extract

tar_gz_extract (alias untgz) extracts a .tar.gz archive.

untgz(slurp("project.tar.gz"), "./extracted")

# zip_create

zip_create creates a ZIP archive from a directory. Returns zip bytes.

my $archive = zip_create("./docs")
spurt("docs.zip", $archive)

# zip_extract

zip_extract extracts a ZIP archive to a directory.

zip_extract(slurp("docs.zip"), "./extracted")

# zip_list

zip_list lists files in a ZIP archive. Returns array of paths.

my @files = @{zip_list(slurp("archive.zip"))}

# md4

md4 computes the MD4 hash and returns a 32-character hex string. MD4 is completely broken — only use for legacy NTLM compatibility or historical systems.

p md4("hello")   # 32 hex chars

# xxh32

xxh32 (alias xxhash32) computes xxHash32 — extremely fast non-cryptographic hash. Optional seed parameter. Returns 8 hex chars.

p xxh32("hello")        # default seed 0
p xxh32("hello", 42)    # with seed

# xxh64

xxh64 (alias xxhash64) computes xxHash64 — fast 64-bit hash. Returns 16 hex chars.

p xxh64("hello")

# xxh3

xxh3 (alias xxhash3) computes xxHash3-64 — newest xxHash variant, fastest on modern CPUs. Returns 16 hex chars.

p xxh3("hello")

# xxh3_128

xxh3_128 computes xxHash3-128. Returns 32 hex chars.

p xxh3_128("hello")

# murmur3

murmur3 (alias murmur3_32) computes MurmurHash3 32-bit. Fast non-cryptographic hash, widely used in hash tables and bloom filters. Optional seed. Returns 8 hex chars.

p murmur3("hello")       # default seed 0
p murmur3("hello", 42)   # with seed

# murmur3_128

murmur3_128 computes MurmurHash3 128-bit (x64 variant). Returns 32 hex chars.

p murmur3_128("hello")

# blowfish_encrypt

blowfish_encrypt (alias bf_enc) encrypts with Blowfish-CBC. Key=4-56 bytes, optional 8-byte IV. Legacy cipher — use AES for new code.

my $ct = blowfish_encrypt($key, "secret")
my $pt = blowfish_decrypt($key, $ct)

# blowfish_decrypt

blowfish_decrypt (alias bf_dec) decrypts Blowfish-CBC.

my $pt = blowfish_decrypt($key, $ciphertext)

# des3_encrypt

des3_encrypt (aliases 3des_enc, tdes_enc) encrypts with Triple DES (3DES) CBC. Key=24 bytes (three 8-byte DES keys). Legacy cipher for PCI-DSS compliance.

my $key = random_bytes(24)
my $ct = des3_encrypt($key, "secret")
my $pt = des3_decrypt($key, $ct)

# des3_decrypt

des3_decrypt (aliases 3des_dec, tdes_dec) decrypts Triple DES (3DES) CBC.

my $pt = des3_decrypt($key, $ciphertext)

# twofish_encrypt

twofish_encrypt (alias tf_enc) encrypts with Twofish-CBC. Key=16/24/32 bytes. AES finalist, still secure.

my $key = random_bytes(32)
my $ct = twofish_encrypt($key, "secret")

# twofish_decrypt

twofish_decrypt (alias tf_dec) decrypts Twofish-CBC.

my $pt = twofish_decrypt($key, $ct)

# camellia_encrypt

camellia_encrypt (alias cam_enc) encrypts with Camellia-CBC. Key=16/24/32 bytes. Japanese/EU standard, equivalent security to AES.

my $ct = camellia_encrypt($key, "secret")

# camellia_decrypt

camellia_decrypt (alias cam_dec) decrypts Camellia-CBC.

my $pt = camellia_decrypt($key, $ct)

# cast5_encrypt

cast5_encrypt encrypts with CAST5-CBC. Key=5-16 bytes. Used in PGP.

my $ct = cast5_encrypt($key, "secret")

# cast5_decrypt

cast5_decrypt decrypts CAST5-CBC.

my $pt = cast5_decrypt($key, $ct)

# salsa20

salsa20 encrypts with Salsa20 stream cipher. Key=32 bytes, nonce auto-generated. Fast, secure stream cipher.

my $ct = salsa20($key, "data")
my $pt = salsa20_decrypt($key, $ct)

# salsa20_decrypt

salsa20_decrypt decrypts Salsa20.

my $pt = salsa20_decrypt($key, $ct)

# xsalsa20

xsalsa20 encrypts with XSalsa20 (extended 24-byte nonce). Safer for random nonces.

my $ct = xsalsa20($key, "data")

# xsalsa20_decrypt

xsalsa20_decrypt decrypts XSalsa20.

my $pt = xsalsa20_decrypt($key, $ct)

# secretbox

secretbox (alias secretbox_seal) is NaCl's symmetric authenticated encryption (XSalsa20-Poly1305). Key=32 bytes. Simple, secure, fast.

my $key = random_bytes(32)
my $ct = secretbox($key, "message")
my $pt = secretbox_open($key, $ct)

# secretbox_open

secretbox_open decrypts and authenticates NaCl secretbox.

my $pt = secretbox_open($key, $ct)

# nacl_box_keygen

nacl_box_keygen generates a NaCl box keypair (X25519). Returns [secret_key_hex, public_key_hex].

my @kp = nacl_box_keygen()
my ($sk, $pk) = @kp

# nacl_box

nacl_box is NaCl's asymmetric authenticated encryption. Takes recipient's public key, sender's secret key, plaintext.

my @alice = nacl_box_keygen()
my @bob = nacl_box_keygen()
my $ct = nacl_box($bob[1], $alice[0], "hello")  # to Bob from Alice
my $pt = nacl_box_open($alice[1], $bob[0], $ct)  # Bob decrypts

# nacl_box_open

nacl_box_open decrypts NaCl box. Takes sender's public key, recipient's secret key, ciphertext.

my $pt = nacl_box_open($sender_pk, $my_sk, $ct)

# erf

erf computes the error function, which arises in probability, statistics, and solutions to the heat equation. erf(x) is the probability that a standard normal random variable falls in [-x√2, x√2]. Returns a value in (-1, 1).

p erf(0)      # 0
p erf(1)      # 0.8427...
p erf(10)     # ~1

# erfc

erfc computes the complementary error function erfc(x) = 1 - erf(x). Numerically stable for large x where erf(x) ≈ 1. Used in computing tail probabilities of normal distributions.

p erfc(0)     # 1
p erfc(3)     # 0.0000220...

# gamma

gamma (alias tgamma) computes the gamma function Γ(x), the extension of factorial to real numbers. Γ(n) = (n-1)! for positive integers. Used throughout statistics, physics, and combinatorics.

p gamma(5)    # 24 (= 4!)
p gamma(0.5)  # √π ≈ 1.7724...
p gamma(1)    # 1

# lgamma

lgamma (alias ln_gamma) computes the natural logarithm of the gamma function: ln(Γ(x)). Avoids overflow for large arguments where Γ(x) would be astronomical. Essential for computing log-probabilities in statistics.

p lgamma(100)  # 359.13...
p lgamma(1000) # 5905.22...

# digamma

digamma (alias psi) computes the digamma function ψ(x) = d/dx ln(Γ(x)), the logarithmic derivative of gamma. Appears in Bayesian statistics (expected log of Dirichlet variables), optimization, and special function theory.

p digamma(1)   # -γ ≈ -0.5772 (Euler-Mascheroni)
p digamma(2)   # 1 - γ ≈ 0.4228

# beta_fn

beta_fn computes the beta function B(a,b) = Γ(a)Γ(b)/Γ(a+b). The beta function is the normalizing constant of the Beta distribution and appears throughout Bayesian statistics and combinatorics.

p beta_fn(2, 3)   # 0.0833...
p beta_fn(0.5, 0.5)  # π

# lbeta

lbeta (alias ln_beta) computes ln(B(a,b)), the log of the beta function. Avoids overflow for small a or b where B(a,b) is very large.

p lbeta(0.01, 0.01)  # large positive

# betainc

betainc (alias beta_reg) computes the regularized incomplete beta function I_x(a,b), the CDF of the Beta distribution. Takes (x, a, b). Essential for computing p-values of F-tests, t-tests, and binomial probabilities.

p betainc(0.5, 2, 3)  # P(Beta(2,3) < 0.5)

# gammainc

gammainc (alias gamma_li) computes the lower incomplete gamma function γ(a,x) = ∫₀ˣ t^(a-1) e^(-t) dt. Used in computing CDFs of gamma and chi-squared distributions.

p gammainc(2, 1)  # γ(2, 1)

# gammaincc

gammaincc (alias gamma_ui) computes the upper incomplete gamma function Γ(a,x) = ∫ₓ^∞ t^(a-1) e^(-t) dt = Γ(a) - γ(a,x). Useful for tail probabilities.

p gammaincc(2, 1)  # Γ(2, 1)

# gammainc_reg

gammainc_reg (alias gamma_lr) computes the regularized lower incomplete gamma P(a,x) = γ(a,x)/Γ(a), the CDF of the gamma distribution Gamma(a, 1).

p gammainc_reg(2, 1)  # P(Gamma(2,1) < 1)

# gammaincc_reg

gammaincc_reg (alias gamma_ur) computes the regularized upper incomplete gamma Q(a,x) = 1 - P(a,x), the survival function of the gamma distribution.

p gammaincc_reg(2, 1)  # P(Gamma(2,1) > 1)

# bessel_j0

bessel_j0 (alias j0) computes the Bessel function of the first kind, order 0.

p j0(0)    # 1.0
p j0(2.4)  # ≈ 0 (first zero)

# bessel_j1

bessel_j1 (alias j1) computes the Bessel function of the first kind, order 1.

p j1(0)    # 0.0
p j1(1.84) # ≈ 0.582 (first max)

# bessel_j

bessel_j N, X — Bessel function of the first kind J_n(x) for integer n. Generalises bessel_j0 / bessel_j1.

p bessel_j(2, 5)   # ≈ 0.0466
p bessel_j(0, 0)   # 1

# bessel_y

bessel_y N, X — Bessel function of the second kind Y_n(x). Singular at x = 0.

p bessel_y(0, 1)   # ≈ 0.0883
p bessel_y(1, 5)   # ≈ 0.1479

# bessel_i

bessel_i N, X — Modified Bessel function I_n(x). Grows exponentially for large x.

p bessel_i(0, 1)   # ≈ 1.266
p bessel_i(2, 3)   # ≈ 2.245

# bessel_k

bessel_k N, X — Modified Bessel function K_n(x). Decays exponentially for large x; singular at 0.

p bessel_k(0, 1)   # ≈ 0.4210
p bessel_k(1, 1)   # ≈ 0.6019

# hankel_h1

hankel_h1 N, X returns the complex Hankel H_n^(1)(x) = J_n(x) + i Y_n(x) as [Re, Im].

my ($re, $im) = hankel_h1(0, 1)
p "$re + i*$im"

# hankel_h2

hankel_h2 N, X returns H_n^(2)(x) = J_n(x) - i Y_n(x) as [Re, Im].

# bessel_j_zero

bessel_j_zero N, K computes the Kth positive zero of J_n. Uses McMahon expansion + Newton refinement.

p bessel_j_zero(0, 1)  # 2.4048…
p bessel_j_zero(1, 1)  # 3.8317…

# airy_ai

airy_ai X — Airy function Ai(x) (decaying solution of y'' = x y).

p airy_ai(0)   # ≈ 0.3550
p airy_ai(2)   # ≈ 0.0349

# airy_bi

airy_bi X — Airy function Bi(x) (growing solution).

# airy_ai_prime

airy_ai_prime X — derivative Ai'(x).

# airy_bi_prime

airy_bi_prime X — derivative Bi'(x).

# spherical_bessel_j

spherical_bessel_j N, X — j_n(x) = √(π/2x) J_{n+1/2}(x).

p spherical_bessel_j(0, 1)  # sin(1)

# spherical_bessel_y

spherical_bessel_y N, X — y_n(x) = √(π/2x) Y_{n+1/2}(x).

# struve_h

struve_h N, X — Struve function H_n(x) (solution of an inhomogeneous Bessel equation).

# struve_l

struve_l N, X — Modified Struve L_n(x).

# kelvin_ber

kelvin_ber X — Real part of J_0(x e^(3πi/4)) (Kelvin function ber₀).

# kelvin_bei

kelvin_bei X — Imaginary part of J_0(x e^(3πi/4)) (Kelvin function bei₀).

# legendre_p

legendre_p N, X — Legendre polynomial P_n(x). Uses the stable Bonnet recurrence (2n+1) x P_n = (n+1) P_{n+1} + n P_{n-1}.

p legendre_p(2, 0.5)  # -0.125
p legendre_p(5, 1)    # 1

# legendre_q

legendre_q N, X — Legendre Q_n(x), the second-kind solution. NaN for |x| ≥ 1.

# assoc_legendre_p

assoc_legendre_p N, M, X — Associated Legendre P_n^m(x). Building block for spherical harmonics.

# hermite_h

hermite_h N, X — Physicist's Hermite H_n(x): H_0=1, H_1=2x, H_{n+1}=2x H_n - 2n H_{n-1}.

p hermite_h(3, 1)   # -4

# hermite_he

hermite_he N, X — Probabilist's Hermite He_n(x): He_0=1, He_1=x, He_{n+1}=x He_n - n He_{n-1}.

# laguerre_l

laguerre_l N, X — Laguerre polynomial L_n(x).

# assoc_laguerre_l

assoc_laguerre_l N, ALPHA, X — Generalised Laguerre L_n^α(x).

# jacobi_p

jacobi_p N, ALPHA, BETA, X — Jacobi polynomial P_n^{(α,β)}(x). Generalises Legendre/Chebyshev/Gegenbauer.

# gegenbauer_c

gegenbauer_c N, ALPHA, X — Gegenbauer C_n^α(x). Reduces to Chebyshev/Legendre at specific α.

# chebyshev_t

chebyshev_t N, X — Chebyshev polynomial of the first kind T_n(x). Recurrence T_{n+1} = 2x T_n - T_{n-1}.

p chebyshev_t(3, 0.5)   # -0.5

# chebyshev_u

chebyshev_u N, X — Chebyshev polynomial of the second kind U_n(x).

# spherical_harmonic_y

spherical_harmonic_y L, M, THETA, PHI — Spherical harmonic Y_l^m(θ, φ) returned as [Re, Im].

# zernike_r

zernike_r N, M, R — Radial Zernike polynomial R_n^m(r). 0 if (n − m) is odd or m > n.

# elliptic_k

elliptic_k M — Complete elliptic integral K(m), m = k². Computed via Carlson R_F.

p elliptic_k(0)    # π/2
p elliptic_k(0.5)  # ≈ 1.8541

# elliptic_e

elliptic_e M — Complete elliptic integral of the second kind E(m).

# elliptic_pi

elliptic_pi N, M — Complete elliptic integral of the third kind Π(n | m).

# elliptic_f

elliptic_f PHI, M — Incomplete F(φ, m).

# elliptic_e_inc

elliptic_e_inc PHI, M — Incomplete E(φ, m).

# elliptic_pi_inc

elliptic_pi_inc N, PHI, M — Incomplete Π(n; φ | m).

# carlson_rf

carlson_rf X, Y, Z — Carlson symmetric form R_F. Building block for the elliptic family.

# carlson_rd

carlson_rd X, Y, Z — Carlson R_D.

# carlson_rj

carlson_rj X, Y, Z, P — Carlson R_J.

# jacobi_sn

jacobi_sn U, M — Jacobi elliptic sn(u, m). Reduces to sin(u) at m = 0 and tanh(u) at m = 1.

p jacobi_sn(1, 0.5)  # ≈ 0.8030

# jacobi_cn

jacobi_cn U, M — Jacobi elliptic cn(u, m). Reduces to cos(u) at m = 0.

# jacobi_dn

jacobi_dn U, M — Jacobi elliptic dn(u, m). Reduces to 1 at m = 0.

# jacobi_am

jacobi_am U, M — Jacobi amplitude φ such that sn(u, m) = sin(φ).

# elliptic_theta

elliptic_theta J, Z, Q — Jacobi theta θ_j(z, q) for j ∈ {1, 2, 3, 4}, |q| < 1.

# weierstrass_p

weierstrass_p Z, G2, G3 — Weierstrass ℘(z; g₂, g₃) via Laurent series. Pole at z = 0.

# weierstrass_zeta

weierstrass_zeta Z, G2, G3 — Weierstrass ζ(z; g₂, g₃).

# weierstrass_sigma

weierstrass_sigma Z, G2, G3 — Weierstrass σ(z; g₂, g₃).

# inverse_jacobi_sn

inverse_jacobi_sn X, M — inverse of jacobi_sn: returns u with sn(u, m) = x.

# zeta

zeta S — Riemann ζ(s) via Euler-Maclaurin (s > 0.5) or reflection identity.

p zeta(2)    # π²/6 ≈ 1.6449
p zeta(4)    # ≈ 1.0823
p zeta(-1)   # -1/12

# hurwitz_zeta

hurwitz_zeta S, A — Hurwitz ζ(s, a). hurwitz_zeta(s, 1) ≡ zeta(s).

# polylog

polylog N, Z — Polylogarithm Li_n(z) = Σ z^k / k^n for |z| ≤ 1.

p polylog(2, 1)    # π²/6

# dilog

dilog Z — Dilogarithm Li_2(z). Convenience alias for polylog(2, z).

# lerch_phi

lerch_phi Z, S, A — Lerch transcendent Φ(z, s, a) = Σ z^k / (a+k)^s.

# riemann_siegel_z

riemann_siegel_z T — Riemann-Siegel Z(t) on the critical line.

# riemann_siegel_theta

riemann_siegel_theta T — Riemann-Siegel θ(t) (asymptotic Stirling form).

# dirichlet_eta

dirichlet_eta S — Dirichlet η(s) = (1 − 2^(1−s)) ζ(s).

# dirichlet_beta

dirichlet_beta S — Dirichlet β(s) = Σ (-1)^k / (2k+1)^s.

p dirichlet_beta(1)   # π/4 (Catalan-like)
p dirichlet_beta(2)   # Catalan's constant ≈ 0.9160

# hypergeometric_2f1

hypergeometric_2f1 A, B, C, Z — ₂F₁(a, b; c; z) Gauss hypergeometric. Series convergent for |z| < 1.

p hypergeometric_2f1(0.5, 0.5, 1, 0.5)  # ≈ 1.1803

# hypergeometric_1f1

hypergeometric_1f1 A, B, Z — ₁F₁(a; b; z) Kummer / confluent hypergeometric.

# hypergeometric_0f1

hypergeometric_0f1 B, Z — ₀F₁(; b; z). Related to Bessel: J_ν(x) = (x/2)^ν / Γ(ν+1) · ₀F₁(; ν+1; -x²/4).

# hypergeometric_pfq

hypergeometric_pfq AS, BS, Z — generalised _pF_q. AS, BS are arrays of upper/lower parameters.

# hypergeometric_u

hypergeometric_u A, B, Z — Tricomi's confluent U(a, b, z).

# dedekind_eta

dedekind_eta Y — Dedekind η(iy) on the imaginary axis. Real-valued q-series with q = exp(-2π y).

# klein_j

klein_j Y — Klein j-invariant j(iy) = E_4³ / Δ.

# modular_lambda

modular_lambda Y — Modular λ(iy) = θ_2(0, q)^4 / θ_3(0, q)^4.

# ramanujan_tau

ramanujan_tau N — τ(n), the nth coefficient of Δ(τ) = η(τ)^24. Returns an integer.

p ramanujan_tau(1)   # 1
p ramanujan_tau(2)   # -24
p ramanujan_tau(3)   # 252

# sin_integral

sin_integral X — Si(x) = ∫₀ˣ sin(t)/t dt. Si(∞) = π/2.

p sin_integral(1)    # ≈ 0.9461
p sin_integral(10)   # ≈ 1.6583

# cos_integral

cos_integral X — Ci(x) = γ + ln(x) + ∫₀ˣ (cos(t)−1)/t dt. NaN for x ≤ 0.

# sinh_integral

sinh_integral X — Shi(x) = ∫₀ˣ sinh(t)/t dt.

# cosh_integral

cosh_integral X — Chi(x) = γ + ln(x) + ∫₀ˣ (cosh(t)−1)/t dt.

# exp_integral_e

exp_integral_e N, X — generalised exponential integral E_n(x) = ∫_1^∞ e^{-x t} / t^n dt.

# exp_integral_ei

exp_integral_ei X — Ei(x). For x > 0 uses series + asymptotic split.

# log_integral

log_integral X — li(x) = Ei(ln x). Approximates the prime-counting function near prime_pi.

p log_integral(1000)   # ≈ 178

# fresnel_s

fresnel_s X — Fresnel S(x) = ∫₀ˣ sin(π t² / 2) dt.

# fresnel_c

fresnel_c X — Fresnel C(x) = ∫₀ˣ cos(π t² / 2) dt.

# jacobi_symbol

jacobi_symbol A, N — Jacobi symbol (a/n) for positive odd n. Returns -1, 0, or 1.

p jacobi_symbol(2, 7)  # 1

# kronecker_symbol

kronecker_symbol A, N — Extension of the Jacobi symbol to all integers n.

# primitive_root

primitive_root P — Smallest primitive root mod p (p prime). undef if none.

# multiplicative_order

multiplicative_order A, N — smallest k > 0 with a^k ≡ 1 (mod n). undef if gcd(a, n) ≠ 1.

# mangoldt_lambda

mangoldt_lambda N — von Mangoldt Λ(n) = ln(p) if n = p^k, else 0.

# carmichael_lambda

carmichael_lambda N — Carmichael λ(n), the exponent of (Z/nZ)*.

p carmichael_lambda(15)   # 4

# squares_r

squares_r K, N — number of representations of n as a sum of k squares (signed, ordered).

p squares_r(2, 5)   # 8 (e.g. ±1²+±2²)

# thue_morse

thue_morse N — Thue-Morse t(n) = popcount(n) mod 2.

# rudin_shapiro

rudin_shapiro N — Rudin-Shapiro sequence, ±1 = (-1)^a(n) where a(n) counts "11" patterns in binary(n).

# farey_sequence

farey_sequence N — Farey sequence F_n. Returns array of [a, b] pairs.

p farey_sequence(3)   # [[0,1],[1,3],[1,2],[2,3],[1,1]]

# frobenius_number

frobenius_number COINS — largest amount NOT representable as a non-negative combination of COINS. Closed form for two coprime denominations.

p frobenius_number([3, 5])   # 7

# frobenius_solve

frobenius_solve COINS, N — number of ways to make change for N using COINS.

# stern_brocot

stern_brocot N — Stern-Brocot tree node N (1-indexed) as [a, b] (Calkin-Wilf order).

# stirling_s1

stirling_s1 N, K — unsigned Stirling number of the first kind |s(n,k)|.

# bell_polynomial_b

bell_polynomial_b N, K, XS — partial Bell polynomial B_{n,k}(x_1, …, x_{n-k+1}).

# clebsch_gordan

clebsch_gordan J1, J2, J, M1, M2 [, M] — Clebsch-Gordan coefficient. M defaults to M1 + M2.

# three_j_symbol

three_j_symbol J1, J2, J3, M1, M2, M3 — Wigner 3-j symbol.

# six_j_symbol

six_j_symbol J1 J2 J3 J4 J5 J6 — Wigner 6-j symbol.

# nine_j_symbol

nine_j_symbol (9 args) — Wigner 9-j as a single sum over 6-j.

# debruijn_sequence

debruijn_sequence K, N — De Bruijn B(k, n) as an array of k^n integers.

# wigner_d

wigner_d J, M1, M2, BETA — small Wigner d-matrix d^j_{m1, m2}(β).

# q_pochhammer

q_pochhammer A, Q [, N] — (a; q)_n. Omit N for the infinite product (|q| < 1).

# q_factorial

q_factorial N, Q — q-factorial [n]_q!.

# q_binomial

q_binomial N, K, Q — Gaussian binomial [n choose k]_q.

# q_hypergeometric_pfq

q_hypergeometric_pfq AS, BS, Q, Z — basic-hypergeometric series.

# mittag_leffler_e

mittag_leffler_e ALPHA, BETA, Z — E_{α,β}(z) = Σ z^k / Γ(α k + β). Generalises exp / cosh / Mittag-Leffler.

# coulomb_wave_f

coulomb_wave_f L, ETA, RHO — regular Coulomb wave F_L(η, ρ) via the confluent-hypergeometric representation.

# coulomb_wave_g

coulomb_wave_g L, ETA, RHO — irregular partner G_L. Currently returns NaN; faithful Bardin/Goesnig port pending.

# inverse_erf

inverse_erf Y — inverse error function. Solves erf(x) = y.

p inverse_erf(0.5)   # ≈ 0.4769

# inverse_erfc

inverse_erfc Y — inverse complementary error function.

# inverse_gamma_regularized

inverse_gamma_regularized A, Y — solves P(a, x) = y for x.

# inverse_beta_regularized

inverse_beta_regularized A, B, Y — solves I_x(a, b) = y for x via bisection.

# dirac_delta

dirac_delta X [, EPS] — finite-width discrete approximation: 1/eps if |x| < eps/2 else 0. EPS defaults to 1e-3.

# heaviside_theta

heaviside_theta X — Heaviside step function: 1 (x > 0), 0 (x < 0), 0.5 (x = 0).

# unit_box

unit_box X — 1 if |x| ≤ 1/2 else 0.

# unit_triangle

unit_triangle X — max(1 − |x|, 0).

# square_wave

square_wave X [, PERIOD] — alternates +1/-1 with the given period (default 1).

# triangle_wave

triangle_wave X [, PERIOD] — periodic triangle wave on [-1, 1].

# sawtooth_wave

sawtooth_wave X [, PERIOD] — periodic sawtooth on [-1, 1].

# dirac_comb

dirac_comb X, T [, EPS] — sum of Dirac deltas at multiples of T (discrete approximation).

# liouville_lambda

liouville_lambda N — Liouville λ(n) = (-1)^Ω(n).

# jordan_totient

jordan_totient K, N — Jordan totient J_k(n) = n^k Π_{p | n} (1 - p^{-k}).

# ramanujan_sum

ramanujan_sum Q, N — c_q(n) = Σ_{d | gcd(q,n)} μ(q/d) d.

# cyclotomic_polynomial

cyclotomic_polynomial N — coefficient list of Φ_n(x).

p cyclotomic_polynomial(6)   # [1, -1, 1] = x²-x+1

# legendre_symbol

legendre_symbol A, P — Legendre symbol (a/p) for prime p. -1, 0, or 1.

# pythagorean_triple_q

pythagorean_triple_q A, B, C — 1 if a² + b² = c² (any order/sign).

# gen_pythagorean_triple

gen_pythagorean_triple M, N — Euclid formula: returns [m²-n², 2mn, m²+n²].

# sophie_germain_q

sophie_germain_q P — 1 if both p and 2p+1 are prime.

# mersenne_q

mersenne_q N — 1 if 2^n - 1 is a Mersenne prime (Lucas-Lehmer).

# lucas_lehmer_test

lucas_lehmer_test P — Lucas-Lehmer primality test for 2^p - 1.

# continued_fraction

continued_fraction X [, N] — first N coefficients of the simple continued-fraction expansion. N defaults to 12.

# from_continued_fraction

from_continued_fraction COEFFS — evaluate [a0; a1, a2, …] back to a real number.

# convergents

convergents X [, N] — N successive [num, denom] convergents.

# best_rational_approximation

best_rational_approximation X, MAX_DENOM — closest fraction p/q with q ≤ MAX_DENOM. Returns [p, q].

# motzkin_number

motzkin_number N — # paths on (0..n) using → ↗ ↘ steps (no crossings).

# narayana_number

narayana_number N, K — N(n, k) = (1/n) C(n,k) C(n,k-1).

# delannoy_number

delannoy_number M, N — # paths in (m+1)×(n+1) grid using → ↑ ↗.

# schroder_number

schroder_number N — large Schröder number.

# small_schroder_number

small_schroder_number N — small Schröder s_n = S_n / 2 (n ≥ 1).

# eulerian_number

eulerian_number N, K — ⟨n k⟩, # permutations of [n] with k ascents.

# bernoulli_polynomial

bernoulli_polynomial N, X — B_n(x).

# euler_polynomial

euler_polynomial N, X — E_n(x).

# pell_number

pell_number N — Pell number P_n.

# pell_lucas_number

pell_lucas_number N — companion Pell-Lucas Q_n.

# perrin_number

perrin_number N — Perrin sequence P(n) = P(n-2) + P(n-3).

# padovan_number

padovan_number N — Padovan sequence (same recurrence, different seeds).

# kronecker_product

kronecker_product A, B — A ⊗ B (block-by-block outer product).

# tensor_product

tensor_product A, B — outer product of two flat vectors → matrix A_i B_j.

# tensor_contract

tensor_contract A, B — Frobenius inner product of two matrices.

# matrix_rank

matrix_rank A — rank via Gaussian elimination with partial pivoting.

# companion_matrix

companion_matrix [a0, a1, …, a_{n-1}] — companion of x^n + a_{n-1} x^{n-1} + … + a_0.

# characteristic_polynomial

characteristic_polynomial A — coefficients [a_0, …, a_n] of det(xI − A) via Faddeev-LeVerrier.

# singular_values

singular_values A — sorted SVDs of A (eigenvalues of A^T A, square-rooted).

# nullspace

nullspace A — basis vectors of A's null space (zero singular values of A^T A).

# polynomial_gcd

polynomial_gcd P, Q — Euclidean GCD over real coefficients (monic).

p polygcd([-1, 0, 1], [-1, 1])   # x - 1

# polynomial_quotient

polynomial_quotient P, Q — quotient of synthetic division.

# polynomial_remainder

polynomial_remainder P, Q — remainder of synthetic division.

# polynomial_resultant

polynomial_resultant P, Q — Sylvester-matrix determinant.

# polynomial_discriminant

polynomial_discriminant P — disc(p) = (-1)^{n(n-1)/2} / a_n · res(p, p').

# polynomial_roots

polynomial_roots P — real roots via deflation power iteration on companion matrix.

# gumbel_pdf

gumbel_pdf X, MU, BETA — Gumbel (Type I) extreme-value PDF.

# gumbel_cdf

gumbel_cdf X, MU, BETA — Gumbel CDF.

# gumbel_quantile

gumbel_quantile P, MU, BETA — Gumbel quantile.

# frechet_pdf

frechet_pdf X, ALPHA, S — Fréchet (Type II) PDF.

# frechet_cdf

frechet_cdf X, ALPHA, S — Fréchet CDF.

# frechet_quantile

frechet_quantile P, ALPHA, S — Fréchet quantile.

# logistic_pdf

logistic_pdf X, MU, S — Logistic PDF.

# logistic_cdf

logistic_cdf X, MU, S — Logistic CDF.

# logistic_quantile

logistic_quantile P, MU, S — Logistic quantile.

# rayleigh_pdf

rayleigh_pdf X, SIGMA — Rayleigh PDF (x ≥ 0).

# rayleigh_cdf

rayleigh_cdf X, SIGMA — Rayleigh CDF.

# rayleigh_quantile

rayleigh_quantile P, SIGMA — Rayleigh quantile.

# inverse_gamma_pdf

inverse_gamma_pdf X, ALPHA, BETA — inverse-gamma PDF.

# inverse_gamma_cdf

inverse_gamma_cdf X, ALPHA, BETA — inverse-gamma CDF.

# inverse_gamma_quantile

inverse_gamma_quantile P, ALPHA, BETA — inverse-gamma quantile.

# kumaraswamy_pdf

kumaraswamy_pdf X, A, B — Kumaraswamy PDF on (0, 1).

# kumaraswamy_cdf

kumaraswamy_cdf X, A, B — Kumaraswamy CDF.

# kumaraswamy_quantile

kumaraswamy_quantile P, A, B — Kumaraswamy quantile.

# mathieu_a

mathieu_a Q, N — Mathieu characteristic value a_n(q) (Hill-matrix eigenvalue).

# mathieu_ce

mathieu_ce N, X, Q — even Mathieu function ce_n(x, q) (perturbative form for small q).

# mathieu_se

mathieu_se N, X, Q — odd Mathieu function se_n(x, q).

# heun_g

heun_g Z, A, Q, ALPHA, BETA, GAMMA, DELTA — general Heun H_l via Frobenius series. Requires |z| < min(1, |a|).

# haar_transform

haar_transform XS — single-level Haar DWT. Returns [approx…, detail…].

# haar_inverse

haar_inverse XS — inverse single-level Haar.

# daubechies_db4

daubechies_db4 XS — single-level Daubechies-4 DWT (length must be even ≥ 4).

# daubechies_db4_inverse

daubechies_db4_inverse XS — inverse single-level db4.

# topo_sort_adj

topo_sort_adj ADJ — Kahn's algorithm on adjacency-list graph. Returns ordering or [] on cycle. (Edge-list input → use topological_sort instead.)

# scc_tarjan

scc_tarjan ADJ — Tarjan strongly-connected components. Returns array of components.

# bipartite_q

bipartite_q ADJ — 1 if graph is 2-colourable (BFS), 0 otherwise.

# max_flow_edmonds_karp

max_flow_edmonds_karp CAP, S, T — max flow on capacity matrix from S to T.

# min_cut

min_cut CAP, S, T — min-cut value (= max-flow).

# eccentricity

eccentricity ADJ, V — max BFS distance from V (unweighted).

# graph_diameter

graph_diameter ADJ — max eccentricity over all vertices.

# graph_radius

graph_radius ADJ — min eccentricity over all vertices.

# stieltjes_constant

stieltjes_constant K — kth Stieltjes constant γ_k. γ_0 = γ (Euler-Mascheroni).

# gauss_sum

gauss_sum A, P — quadratic Gauss sum G(a, p) as [Re, Im].

# kloosterman_sum

kloosterman_sum A, B, M — K(a, b; m) as [Re, Im].

# eta_quotient

eta_quotient PAIRS, Y — Π η(d·iy)^{r_d} for [[d, r_d], …].

# root_approximant

root_approximant X [, MAX_DENOM] — best rational approximant (alias for best_rational_approximation).

# numerical_gradient

numerical_gradient F, POINT [, H] — central-difference ∇f. F receives a single arrayref _0.

fn quad { my @y = @{_0}; $y[0]**2 + 2*$y[1]**2 }
my @g = ngrad(\&quad, [3, 4])    # (6, 16)

# numerical_jacobian

numerical_jacobian F, POINT [, H] — Jacobian of vector-valued F.

# numerical_hessian

numerical_hessian F, POINT [, H] — symmetric Hessian via mixed second differences.

# numerical_divergence

numerical_divergence F, POINT [, H] — div of vector field F.

# numerical_curl

numerical_curl F, POINT [, H] — 3-D curl returned as [c_x, c_y, c_z].

# numerical_laplacian

numerical_laplacian F, POINT [, H] — ∇²f.

# nelder_mead

nelder_mead F, X0 [, MAX_ITER, TOL] — Nelder-Mead simplex minimisation. Returns [x*, f(x*)].

# gradient_descent

gradient_descent F, GRAD, X0 [, STEP, ITERS] — fixed-step descent.

# bfgs_minimize

bfgs_minimize F, GRAD, X0 [, MAX_ITER, TOL] — BFGS quasi-Newton with Armijo line search.

# levenberg_marquardt

levenberg_marquardt F_RESID, X0 [, MAX_ITER, TOL] — nonlinear LSQ. F returns the residual vector.

# conjugate_gradient

conjugate_gradient A, B — CG for symmetric positive definite A x = b.

# least_squares

least_squares A, B — solves A^T A x = A^T b.

# romberg

romberg F, A, B [, LEVELS] — Romberg integration. Doubles trapezoid then Richardson-extrapolates.

# gauss_legendre_quad

gauss_legendre_quad F, A, B [, N] — N-point Gauss-Legendre quadrature on [a, b] (default N=10).

# monte_carlo_integrate

monte_carlo_integrate F, A, B [, N] — uniform Monte Carlo over [a, b] with N samples (default 10 000).

# adaptive_simpson

adaptive_simpson F, A, B [, TOL, MAX_DEPTH] — adaptive Simpson with Richardson tail.

# lu_decompose

lu_decompose A → [L, U, P] with P A = L U; P stored as a row-permutation vector.

# qr_decompose

qr_decompose A → [Q, R] via Gram-Schmidt.

# householder_reflector

householder_reflector V → I − 2 v v^T / (v · v).

# givens_rotation

givens_rotation A, B → [c, s] such that the rotation [c -s; s c] zeros the second component.

# forward_substitute

forward_substitute L, B — solve L x = b for lower-triangular L.

# back_substitute

back_substitute U, B — solve U x = b for upper-triangular U.

# hessenberg_reduce

hessenberg_reduce A — orthogonal Hessenberg form via Householder reflections.

# poly_derivative

poly_derivative P — coefficient-list derivative of polynomial P (low-to-high order).

# poly_integrate

poly_integrate P [, C] — antiderivative with constant C (default 0).

# poly_compose

poly_compose P, Q → coefficients of P(Q(x)).

# poly_eval_horner

poly_eval_horner P, X — Horner-rule polynomial evaluation.

# pade_approximant

pade_approximant TAYLOR, M, N → [num, den] Padé approximation.

# quat_mul

quat_mul A, B — Hamilton product (w, x, y, z).

# quat_conj

quat_conj Q — conjugate (w, -x, -y, -z).

# quat_norm

quat_norm Q — Euclidean norm.

# quat_inv

quat_inv Q — inverse Q* / |Q|².

# quat_from_axis_angle

quat_from_axis_angle AXIS, THETA — unit quaternion encoding rotation about AXIS by THETA radians.

# quat_to_axis_angle

quat_to_axis_angle Q → [axis, theta].

# quat_to_matrix

quat_to_matrix Q → 3×3 rotation matrix.

# quat_from_matrix

quat_from_matrix R — Shepherd's algorithm.

# quat_slerp

quat_slerp A, B, T — spherical-linear interpolation between two unit quaternions.

# euler_zyx_to_matrix

euler_zyx_to_matrix YAW, PITCH, ROLL — intrinsic Z-Y-X Euler rotation.

# matrix_to_euler_zyx

matrix_to_euler_zyx R → [yaw, pitch, roll].

# rotate_3d_vec

rotate_3d_vec Q, V — apply quaternion rotation to a 3-vector.

# kl_divergence

kl_divergence P, Q — D_KL(P || Q) in nats.

# js_divergence

js_divergence P, Q — Jensen-Shannon divergence.

# mutual_information

mutual_information JOINT — I(X; Y) from a joint-probability matrix.

# cross_entropy_arr

cross_entropy_arr P, Q — H(P, Q) = -Σ p log q.

# renyi_entropy

renyi_entropy P [, ALPHA] — Rényi entropy of order α (default 2).

# tsallis_entropy

tsallis_entropy P [, Q] — Tsallis entropy of order q (default 2).

# pauli_x

pauli_x — 2×2 σ_x matrix.

# pauli_y

pauli_y — 2×2 σ_y matrix encoded with [Re, Im] entries (since stryke matrices are real).

# pauli_z

pauli_z — 2×2 σ_z matrix.

# pauli_id

pauli_id — 2×2 identity.

# ket_bra

ket_bra PSI, PHI → outer product |ψ⟩⟨φ| of two real vectors.

# density_matrix

density_matrix PSI → ρ = |ψ⟩⟨ψ| (real-valued).

# expectation_value

expectation_value OP, PSI → ⟨ψ|O|ψ⟩.

# commutator

commutator A, B — [A, B] = AB − BA.

# anticommutator

anticommutator A, B — {A, B} = AB + BA.

# partial_trace

partial_trace RHO, DIMS, KEEP — partial trace over subsystems whose indices are not in KEEP.

# von_neumann_entropy

von_neumann_entropy RHO — S(ρ) = -tr(ρ log ρ) for symmetric ρ.

# bose_einstein

bose_einstein E, MU, KT — 1 / (exp((E - μ)/kT) - 1).

# fermi_dirac

fermi_dirac E, MU, KT — 1 / (exp((E - μ)/kT) + 1).

# maxwell_boltzmann_speed

maxwell_boltzmann_speed V, M, KT — Maxwell-Boltzmann speed PDF.

# partition_function

partition_function ENERGIES, KT — Z = Σ exp(-E_i / kT).

# helmholtz_free_energy

helmholtz_free_energy Z, KT — F = -kT ln Z.

# boltzmann_factor

boltzmann_factor E, KT — exp(-E / kT).

# einstein_specific_heat

einstein_specific_heat T, THETA_E — Einstein heat-capacity model (J / mol·K).

# fresnel_reflection_te

fresnel_reflection_te THETA_I, N1, N2 — TE (s-polarisation) reflection coefficient.

# fresnel_reflection_tm

fresnel_reflection_tm THETA_I, N1, N2 — TM (p-polarisation) reflection.

# fresnel_transmission_te

fresnel_transmission_te THETA_I, N1, N2 — TE transmission.

# fresnel_transmission_tm

fresnel_transmission_tm THETA_I, N1, N2 — TM transmission.

# abcd_thin_lens

abcd_thin_lens F — ABCD ray matrix for a thin lens of focal length F.

# abcd_free_space

abcd_free_space D — ABCD matrix for free-space propagation D.

# gaussian_beam_q

gaussian_beam_q Z, W0, LAMBDA → [Re(q), Im(q)] for a Gaussian beam at distance Z.

# kepler_solve

kepler_solve M, E — solve Kepler's equation M = E - e sin(E) by Newton iteration.

# true_to_eccentric

true_to_eccentric NU, E → eccentric anomaly E.

# eccentric_to_mean

eccentric_to_mean E, ECC → mean anomaly M.

# julian_date

julian_date Y, M, D, H, MN, S — Julian date (Meeus formula).

# jd_to_gregorian

jd_to_gregorian JD → [Y, M, D.dd].

# sidereal_time_gmst

sidereal_time_gmst JD — Greenwich Mean Sidereal Time in radians.

# vis_viva

vis_viva R, A, MU — orbital speed from vis-viva equation.

# orbital_period_kepler

orbital_period_kepler A, MU — T = 2π √(a³ / μ).

# orbital_elements_to_state

orbital_elements_to_state A, E, I, OM, W, NU, MU → [r_x, r_y, r_z, v_x, v_y, v_z].

# kalman_step

kalman_step X, P, F, H, Q, R, Z → [X', P'] — single Kalman predict-and-update step.

# exponential_smoothing

exponential_smoothing XS, ALPHA — first-order EMA.

# holt_winters

holt_winters XS, ALPHA, BETA, GAMMA, PERIOD — additive triple exponential smoothing.

# arma_yw_fit

arma_yw_fit XS, P — Yule-Walker AR(p) coefficients via Levinson-Durbin.

# pagerank

pagerank ADJ [, DAMPING, ITERS] — PageRank via power iteration. Default damping 0.85, 100 iters.

# betweenness_centrality

betweenness_centrality ADJ — Brandes' algorithm (unweighted).

# closeness_centrality

closeness_centrality ADJ — closeness centrality. 0 for disconnected vertices.

# eigenvector_centrality

eigenvector_centrality ADJ — power iteration on the adjacency matrix.

# degree_centrality

degree_centrality ADJ — degree / (n - 1).

# triangle_count

triangle_count ADJ — number of triangles incident at each vertex.

# rgumbel

rgumbel MU, BETA — Gumbel sample.

# rfrechet

rfrechet ALPHA, S — Fréchet sample.

# rrayleigh

rrayleigh SIGMA — Rayleigh sample.

# rlogistic

rlogistic MU, S — logistic sample.

# rkumaraswamy

rkumaraswamy A, B — Kumaraswamy sample on (0, 1).

# rinverse_gamma

rinverse_gamma ALPHA, BETA — inverse-gamma sample (Marsaglia-Tsang).

# graham_scan

graham_scan POINTS — 2-D convex hull (CCW).

# line_line_intersect_2d

line_line_intersect_2d P1, P2, P3, P4 → intersection [x, y] or undef when parallel.

# point_segment_distance

point_segment_distance P, A, B — Euclidean distance from P to segment AB.

# forward_diff

forward_diff F, X — derivative of scalar f at scalar x (Julia ForwardDiff style; central-difference fallback).

# forward_diff_grad

forward_diff_grad F, X_VEC — gradient at vector x; alias for numerical_gradient.

# bartlett_test

bartlett_test GROUPS — Bartlett's k-sample variance equality test. Returns [chi², df, p].

# levene_test

levene_test GROUPS — Levene's variance-equality test. Returns [F, df1, df2, p].

# fishers_exact_test_2x2

fishers_exact_test_2x2 [[a, b], [c, d]] — two-sided p-value.

# mcnemar_test

mcnemar_test [[a, b], [c, d]] — paired 2×2 table with continuity correction. Returns [chi², p].

# runs_test

runs_test SEQ — Wald-Wolfowitz runs test on a binary sequence. Returns [Z, p].

# friedman_test

friedman_test BLOCKS_BY_TREATMENTS — non-parametric ANOVA on ranks. Returns [Q, df, p].

# kruskal_wallis_test

kruskal_wallis_test GROUPS — non-parametric ANOVA. Returns [H, df, p].

# sign_test

sign_test PAIRS — paired sign test. Returns [N+, p].

# anderson_darling_normality

anderson_darling_normality XS — A² statistic. > 0.752 → reject normality at α=0.05.

# jarque_bera_test

jarque_bera_test XS — normality test from sample skewness + kurtosis.

# ljung_box_test

ljung_box_test XS [, H] — autocorrelation test. Returns [Q, h, p].

# durbin_watson_stat

durbin_watson_stat RESID — DW autocorrelation statistic on residuals.

# mahalanobis_distance

mahalanobis_distance X, MU, SIGMA — √((x-μ)ᵀ Σ⁻¹ (x-μ)).

# cosine_distance

cosine_distance A, B — 1 − cos(A, B).

# canberra_distance

canberra_distance A, B — Σ |a-b| / (|a|+|b|).

# bray_curtis_distance

bray_curtis_distance A, B — Σ|a-b| / Σ(a+b).

# l1_distance

l1_distance A, B — Manhattan / taxi-cab distance.

# chi_squared_distance

chi_squared_distance A, B — ½ Σ (a-b)² / (a+b).

# multivariate_normal_pdf

multivariate_normal_pdf X, MU, SIGMA — multivariate Gaussian PDF.

# multivariate_normal_sample

multivariate_normal_sample MU, SIGMA — sample from MVN via Cholesky.

# dirichlet_pdf

dirichlet_pdf X, ALPHA — Dirichlet PDF on the simplex.

# dirichlet_sample

dirichlet_sample ALPHA — sample via independent Gamma draws.

# skellam_pmf

skellam_pmf K, MU1, MU2 — difference of two independent Poisson(μ) variates.

# inverse_gaussian_pdf

inverse_gaussian_pdf X, MU, LAMBDA — Wald PDF.

# inverse_gaussian_cdf

inverse_gaussian_cdf X, MU, LAMBDA — Wald CDF.

# inverse_gaussian_sample

inverse_gaussian_sample MU, LAMBDA — Michael-Schucany-Haas.

# non_central_chi2_pdf

non_central_chi2_pdf X, K, LAMBDA — Series-form non-central χ² PDF.

# matrix_exp

matrix_exp A — e^A via 13-term Padé + scaling-and-squaring.

# matrix_log

matrix_log A — ln A via inverse scaling (Denman-Beavers SQRT) + Padé log.

# matrix_sqrt

matrix_sqrt A — A^(1/2) via Denman-Beavers iteration.

# matrix_sin

matrix_sin A — series form Σ (-1)^k A^(2k+1) / (2k+1)!.

# matrix_cos

matrix_cos A — series form Σ (-1)^k A^(2k) / (2k)!.

# rk45_dormand_prince

rk45_dormand_prince F, Y0, T0, T1, H0 [, TOL] — adaptive Dormand-Prince. F receives [t, y0, …].

# midpoint_step

midpoint_step F, Y, T, H — single explicit-midpoint step.

# heun_step

heun_step F, Y, T, H — improved-Euler / Heun step.

# verlet_step

verlet_step ACCEL, Q, P, T, H — velocity-Verlet symplectic step.

# logistic_regression

logistic_regression X, Y — IRLS (no intercept added — supply column of ones).

# poisson_regression

poisson_regression X, Y — IRLS with log link.

# ridge_regression

ridge_regression X, Y [, LAMBDA] — Tikhonov-regularised LSQ.

# lasso_coord

lasso_coord X, Y [, LAMBDA, MAX_ITER] — coordinate-descent LASSO.

# bootstrap_mean_ci

bootstrap_mean_ci DATA [, B, ALPHA] — percentile CI for the mean.

# jackknife_estimate

jackknife_estimate DATA — leave-one-out SE of the mean.

# permutation_test_diff

permutation_test_diff A, B [, N_ITER] — two-sided p of mean difference.

# acf_at_lag

acf_at_lag XS, LAG — autocorrelation at one lag.

# diff_op

diff_op XS [, LAG] — y_t − y_{t-lag}.

# lag_op

lag_op XS [, K] — shift by k (NaN-pad).

# decompose_classical

decompose_classical XS [, PERIOD] — additive [trend, season, residual].

# combinations_list

combinations_list N, K — all k-subsets of 0..n in lex order.

# permutations_list

permutations_list N — all permutations of 0..n via Heap's algorithm.

# cyclic_permutations

cyclic_permutations ARR — all rotations.

# subsets_of_size

subsets_of_size ARR, K — all k-subsets of an arbitrary array.