// 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
sub double { $_0 * 2 }
my @r = pmap double, (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
sub even { $_0 % 2 == 0 }
my @e = pgrep 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
sub work { print "did $_0\n" }
pfor work, (1, 2, 3)

# psort

Parallel sort that uses rayon's parallel merge-sort algorithm. Accepts an optional comparator block using $_0/$_1 (or $a/$b). 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 { $_0 <=> $_1 } @big_list
my @by_name = psort { $_0->{name} cmp $_1->{name} } @records
@nums |> psort { $a <=> $b } |> 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 { $_0 + $_1 } @nums
my $biggest = preduce { $_0 > $_1 ? $_0 : $_1 } @vals
my $product = preduce { $a * $b } 1:100

# preduce_init

Parallel fold with identity value.

my $total = preduce_init 0, { $_0 + $_1 } @list

# pmap_reduce

Fused parallel map + tree reduce.

my $sum = pmap_reduce { _*2 } { $_0 + $_1 } @list

# pany

pany { COND } @list — parallel short-circuit any.

# pfirst

pfirst { COND } @list — parallel first matching element.

# puniq

puniq @list — parallel unique elements.

# 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
sub expand { ($_0, $_0 * 10) }
my @r = pflat_map expand, (1, 2, 3)   # (1, 10, 2, 20, 3, 30)

# pflat_maps

Streaming parallel flat-map — like pmaps but flattens array results. Returns a lazy iterator.

range(0, 1e6) |> pflat_maps { [_, _ * 10] } |> ep

# fan

Execute BLOCK or FUNC N times in parallel (_/$_0 = 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
sub work { print "tick $_0\n" }
fan 8, work
fan work, 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
sub compute { $_0 * $_0 }
my @squares = fan_cap 8, compute

# mysync

Declare shared variables for parallel blocks (Arc<Mutex>).

mysync $counter = 0
fan 10000 { $counter++ }   # always exactly 10000
mysync @results
mysync %histogram$1

Compound ops (`++`, `+=`, `.=`, `|=`, `&=`) are fully atomic.

# 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(@channels) — wait on multiple pchannel receivers.

# barrier

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

Each thread calls $b->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 $b = barrier(4)
for my $i (0:3) {
    spawn {
        setup_phase($i)
        $b->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 { $_0 <=> $_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 take_n { @_[0..$_[-1]-1] }               # take_n(list, n)
~>> (1,2,3,4,5) take_n(3) p                  # take_n(1,2,3,4,5, 3) = (1,2,3)

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

# 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 { $_0 + $_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 and mirrors Perl's List::Util::tail. 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 { length(_) > 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 using $_0 and $_1 (stryke style) or $a and $b (classic Perl) to control ordering: 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 { $_0 <=> $_1 } @nums
@asc |> e p   # 1 1 3 4 5
sort { |$x, $y| $y <=> $x }, @nums   # named params
my @desc = sort { $_1 <=> $_0 } @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 { $_0 OP $_1 } @list — performs a sequential left fold over the list. The first two elements are passed as $_0 and $_1 to the block; the result becomes $_0 for the next iteration. The traditional $a/$b names are also supported for Perl compatibility. 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 { $_0 * $_1 } 1:6
p $fac   # 720
reduce { |$acc, $val| $acc + $val }, 1:10   # 55 (named params)
my $longest = reduce { length($_0) > length($_1) ? $_0 : $_1 } @words

# fold

fold { $_0 OP $_1 } INIT, @list — left fold with an explicit initial accumulator value. The initial value is passed as the first $_0, and each list element arrives as $_1. Unlike reduce, fold never returns undef for an empty list — it returns the initial value instead. Both $a/$b and $_0/$_1 are supported in the block. Use fold when you need a guaranteed starting point for the accumulation.

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

# reductions

reductions { $_0 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. Both $_0/$_1 and $a/$b naming conventions are supported.

my @pfx = reductions { $_0 + $_1 } 1:4
@pfx |> e p   # 1 3 6 10
1:5 |> reductions { $_0 * $_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. This is the stryke equivalent of Perl's List::Util::any 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 built-in that does not require use List::Util 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 built-in; no use List::Util 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 $_0 (or $a) and the value as $_1 (or $b). 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 { "$_0=$_1" } "a", 1, "b", 2
@out |> e p   # a=1 b=2
my @cfg_pairs = (host => "x", port => 80)
my @upper = pairmap { uc($_0), $_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 available as $_0 (or $a) and the value as $_1 (or $b). 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 { $_0 =~ /^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 $_0 (or $a) and the value is $_1 (or $b). 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 { $_0 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 — pipeline / string helpers builtin. Alias for drop.

my $result = partition $x 
# or in a pipeline:
@list |> map partition |> p

# 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 — pipeline / string helpers builtin.

my $result = select_keys $x 
# or in a pipeline:
@list |> map select_keys |> p

# 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

# 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 double($x) { $x * 2 }
my $f = fn { _ * 2 }
my $add = fn ($a: Int, $b: Int) { $a + $b }

# 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 $a = Point(1, 2)
my $b = Point(1, 2)
p $a == $b  # 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 ($a: Int, $b: Int) { $a + $b }
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.

# 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 — alias for say (print with newline).

p "hello"       # hello\n
p 42            # 42\n
1:5 |> e p     # prints each on its own line

# 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 ($a, $b) = (0, 1)
    while (1) {
        yield $a
        ($a, $b) = ($b, $a + $b)
    }
}
for (1:10) {
    my ($val) = @{$fib->next}
    p $val
}

# trace

Trace mysync mutations to stderr (tagged with worker index under fan).

trace { fan 10 { $counter++ } }

# timer

Measure wall-clock milliseconds for a block.

my $ms = timer { heavy_work() }

# 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

Limit invocations per time window.

rate_limit(10, "1s") { hit_api() }

# every

Run a block at a fixed interval.

every "500ms" { tick() }

# watch

Watch a single file for changes (non-parallel).

watch "/tmp/x", fn { process }

# 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 Perl data structure — hashrefs, arrayrefs, nested combinations, numbers, strings, booleans, and undef — into a compact JSON string. It uses a fast Rust-backed serializer so it is significantly faster than JSON::XS for large payloads. 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`; Perl 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://github.com/MenkeTechnologies/stryke"
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. 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 similar to Perl's Data::Dumper. 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

# 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)

# 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)

# par_lines

par_lines PATH, { code } — memory-map a file and scan its lines in parallel across all available CPU cores.

The file is mmap'd into memory rather than read sequentially, and line boundaries are detected in parallel chunks. Each line is passed to the callback as _. Because the file is memory-mapped, there is no read-buffer overhead and the OS kernel pages data in on demand, making par_lines extremely efficient for multi-gigabyte log files or CSV data. Line order within the callback is not guaranteed (lines run in parallel), so the callback should be a self-contained side-effecting operation (accumulate into a shared structure via pchannel, write to a file, etc.) or use par_lines with a reducer. For ordered processing, use read_lines with pmap instead.

par_lines "data.txt", fn { process }

# Count matching lines in a large log:
my $count = 0
par_lines "/var/log/syslog", fn { $count++ if /ERROR/ }
p $count

# Feed lines into a channel for downstream processing:
my ($tx, $rx) = pchannel(1000)
async { par_lines "huge.csv", fn { $tx->send(_) }
    undef $tx }

# par_walk

par_walk PATH, { code } — recursively walk a directory tree in parallel, invoking the callback for every file path found.

Directory traversal is parallelized using a work-stealing thread pool: multiple directories are read concurrently, and the callback fires as each file is discovered. The path is passed as _ (absolute). This is significantly faster than a sequential find-style walk on SSDs and networked filesystems where directory readdir latency dominates. Symlinks are not followed by default to avoid cycles. The walk visits files only — directories themselves are not passed to the callback unless you pass dirs => 1. Combine with pmap for a two-phase pattern: first collect paths with par_walk, then process file contents in parallel.

par_walk "./src", fn { p _ if /\.rs$/ }

# Collect all JSON files under a directory:
my @json_files
par_walk "/data", fn { push @json_files, _ if /\.json$/ }
p scalar @json_files

# Parallel content search:
par_walk ".", fn {
    if (/\.log$/) {
        my @hits = grep /FATAL/, rl
        p "_: ", scalar @hits, " fatals" if @hits
    }
}

# par_sed

par_sed PATTERN, REPLACEMENT, @files — perform an in-place regex substitution across multiple files in parallel.

Each file is processed by a separate worker thread: the file is read into memory, all matches of PATTERN are replaced with REPLACEMENT, and the result is written back atomically (via a temp file + rename, so readers never see a partially-written file). This is the stryke equivalent of sed -i but parallelized across the file list — ideal for codebase-wide refactors, log scrubbing, or bulk config updates. The pattern uses stryke regex syntax (PCRE-style). Returns the total number of substitutions made across all files.

par_sed qr/oldFunc/, "newFunc", glob("src/*.pl")

# Case-insensitive replace across a project:
par_sed qr/TODO/i, "DONE", par_walk(".", fn { _ if /\.rs$/ })

# Scrub sensitive data from logs:
my $n = par_sed qr/\b\d{3}-\d{2}-\d{4}\b/, "XXX-XX-XXXX", @log_files
p "redacted $n occurrences"

# par_find_files

Recursively search a directory tree in parallel for files matching a glob pattern. Unlike glob_par which takes a single pattern string, par_find_files separates the root directory from the pattern, making it convenient when the search root is a variable. Returns a list of absolute paths to matching files.

my @src = par_find_files("src", "*.rs")
p scalar @src                    # count of Rust files under src/
my @tests = par_find_files(".", "*_test.pl")
@tests |> e p
my @configs = par_find_files("/etc", "*.conf")

# par_line_count

Count lines across multiple files in parallel, returning the total line count. Each file is read and counted by a separate thread, making this dramatically faster than sequential wc -l for large file sets. Useful for codebase metrics, log analysis, or validating data pipeline output.

my @files = glob("src/**/*.rs")
my $total = par_line_count(@files)
p "$total lines of Rust"
my $logs = par_line_count(glob("/var/log/*.log"))
p "$logs log lines"

# par_csv_read

par_csv_read @files — read multiple CSV files in parallel, returning an array of parsed datasets (one per file).

Each file is read and parsed by a separate worker thread using a fast Rust CSV parser that handles quoting, escaping, and UTF-8 correctly. Headers are auto-detected from the first row of each file, and each row is returned as a hashref keyed by header names. This is dramatically faster than sequential CSV parsing when you have many files — common in data engineering pipelines where data arrives as daily/hourly CSV partitions. For a single large CSV file, prefer par_lines with manual splitting, since par_csv_read parallelizes across files, not within a single file.

my @datasets = par_csv_read glob("data/*.csv")
for my $ds (@datasets) {
    p scalar @$ds, " rows"
}

# Merge all CSVs into one list:
my @all_rows = par_csv_read(@files) |> flat
p $all_rows[0]->{name}                # access by header

# Filter and aggregate:
my @sales = par_csv_read(glob("sales_*.csv")) |> flat
  |> grep { _->{region} eq "US" }

# glob_par

Perform a parallel recursive file-system glob, using multiple threads to walk directory trees concurrently. This is significantly faster than glob for deep directory hierarchies with thousands of files. Accepts the same glob syntax (*, **, {a,b}) but returns results as they are discovered across threads. Ideal for large codebases or log directories.

my @logs = glob_par("**/*.log")
p scalar @logs               # count of log files
"**/*.rs" |> glob_par |> e p  # print all Rust files
my @imgs = glob_par("assets/**/*.{png,jpg,webp}")
@imgs |> e { p bn(_) }

# pwatch

pwatch(PATH, fn { ... }) — watch a file or directory for filesystem changes and invoke the callback on each event.

The watcher runs on a background thread using OS-native notifications (FSEvents on macOS, inotify on Linux) so it consumes near-zero CPU while idle. The callback receives the event type and affected path in _. Directory watches are recursive by default. The watcher continues until the returned handle is dropped or the program exits. This is useful for building live-reload dev servers, file-triggered pipelines, or audit logs. Combine with debounce or a pchannel if the callback is expensive and rapid bursts of events need to be coalesced.

my $w = pwatch "./src", fn {
    p "changed: $_"
    rebuild()
}

# Watch multiple paths:
my $w1 = pwatch "/var/log/app.log", fn { p "log updated" }
my $w2 = pwatch "./config", fn { reload_config() }
sleep                                 # block forever

# open

Open a filehandle for reading, writing, appending, or piping. The three-argument form open my $fh, MODE, EXPR is strongly preferred for safety — it prevents shell injection and makes the mode explicit. Modes include < (read), > (write/truncate), >> (append), +< (read-write), |- (pipe to command), and -| (pipe from command). In stryke, always use lexical filehandles (my $fh) rather than bareword globals. PerlIO layers can be specified in the mode: <:utf8, <:raw, <:encoding(UTF-16). Always check the return value — open ... or die "...: $!" is idiomatic. The $! variable contains the OS error message on failure. Forgetting to check open is one of the most common bugs in Perl code.

open my $fh, '<', 'data.txt' or die "open: $!"
my @lines = <$fh>
close $fh

open my $out, '>>', 'log.txt' or die "append: $!"
print $out tm "event happened\n"
close $out

open my $pipe, '-|', 'ls', '-la' or die "pipe: $!"
while (<$pipe>) { p tm _ }

# close

Close a filehandle, flushing any buffered output and releasing the underlying OS file descriptor. Returns true on success, false on failure — and failure is more common than you might think. For write handles, close is where buffered data actually hits disk, so a full disk or network error may only surface at close time. Always check the return value when writing: close $fh or die "close: $!". For pipe handles opened with |- or -|, close waits for the child process to exit and sets $? to the child's exit status. In stryke, lexical filehandles are automatically closed when they go out of scope, but explicit close is clearer and lets you handle errors.

open my $fh, '>', 'out.txt' or die $!
print $fh "done\n"
close $fh or die "write failed: $!"

open my $p, '|-', 'gzip', '-c' or die $!
print $p $data
close $p
p "gzip exited: $?" if $?

# read

Read a specified number of bytes from a filehandle into a scalar buffer. The signature is read FH, SCALAR, LENGTH [, OFFSET]. Returns the number of bytes actually read (which may be less than requested at EOF or on partial reads), 0 at EOF, or undef on error. The optional OFFSET argument lets you append to an existing buffer at a given position, which is useful for accumulating data in a loop. For text files, the bytes are decoded according to the handle's PerlIO layer — use <:raw for binary data to avoid encoding transforms. In stryke, read works identically to Perl 5. For line-oriented input, prefer <$fh> or readline instead.

open my $fh, '<:raw', $path or die $!
my $buf = ''
while (read $fh, my $chunk, 4096) {
    $buf .= $chunk
}
p "total: " . length($buf) . " bytes"
close $fh

# readline

Read one line (or all remaining lines in list context) from a filehandle. The angle-bracket operator <$fh> is syntactic sugar for readline($fh). In scalar context, returns the next line including the trailing newline (or undef at EOF). In list context, returns all remaining lines as a list. The line ending is determined by $/ (input record separator, default \n). Set $/ = undef to slurp the entire file in one read. In stryke, readline integrates with the pipe operator — you can pipe filehandle lines through maps, greps, and other streaming combinators. Always chomp after reading if you don't want trailing newlines.

while (my $line = <$fh>) {
    chomp $line
    p $line
}

# Slurp entire file
local $/
my $content = <$fh>
p length $content

# eof

Test whether a filehandle has reached end-of-file. Returns 1 if the next read on the handle would return EOF, 0 otherwise. Called without arguments, eof() (with parens) checks the last file in the <> / ARGV stream. Called with no parens as eof, it tests whether the current ARGV file is exhausted but more files may follow. In stryke, eof is typically used in until loops or as a guard before read calls. Note that eof may trigger a blocking read on interactive handles (like STDIN from a terminal) to determine if data is available, so avoid calling it speculatively on interactive input. For most line-processing, while (<$fh>) is simpler and implicitly handles EOF.

until (eof $fh) {
    my $line = <$fh>
    p tm $line
}

# Process multiple files via ARGV
while (<>) {
    p "new file: $ARGV" if eof()
}

# seek

Reposition a filehandle to an arbitrary byte offset. The signature is seek FH, POSITION, WHENCE where WHENCE is 0 (absolute from start), 1 (relative to current position), or 2 (relative to end of file). Use the Fcntl constants SEEK_SET, SEEK_CUR, SEEK_END for clarity. Returns 1 on success, 0 on failure. seek is essential for random-access file I/O — re-reading headers, skipping to known offsets in binary formats, or rewinding a file for a second pass. In stryke, seek flushes the PerlIO buffer before repositioning. Do not mix seek/tell with sysread/syswrite — they use separate buffering layers.

seek $fh, 0, 0         # rewind to start
my $header = <$fh>

seek $fh, -100, 2      # last 100 bytes
read $fh, my $tail, 100
p $tail

# tell

Return the current byte offset of a filehandle's read/write position. Returns a non-negative integer on success, or -1 if the handle is invalid or not seekable (e.g., pipes, sockets). Useful for bookmarking a position before a speculative read so you can seek back if the data doesn't match expectations. In stryke, tell reflects the PerlIO buffered position, not the raw OS file descriptor position — so it correctly accounts for encoding layers and buffered reads. Pair with seek for random-access patterns.

my $pos = tell $fh
p "at byte $pos"

# Bookmark and restore
my $mark = tell $fh
my $line = <$fh>
unless ($line =~ /^HEADER/) {
    seek $fh, $mark, 0   # rewind to before the read
}

# print

Write operands to the selected output handle (default STDOUT) without appending a newline. The output field separator $, is inserted between arguments, and $\ is appended at the end — both default to empty string. You can direct output to a specific handle by passing it as the first argument with no comma: print STDERR "msg". In stryke, print behaves identically to Perl 5 and is useful when you need precise control over output formatting, such as building progress bars, writing binary data, or emitting partial lines. For most line-oriented output, prefer p (say) instead since it handles the newline automatically.

print "no newline"
print STDERR "error msg\n"
print $fh "data to filehandle\n"
for my $pct (0:100) {
    printf "\rprogress: %3d%%", $pct
}
print "\n"

# say

Print operands followed by an automatic newline to STDOUT. In stryke, say is always available without -E or use feature 'say' — it is a first-class builtin. The shorthand p is an alias for say and is preferred in most stryke code. When given a list, say joins elements with $, (output field separator, empty by default) and appends $\ plus a newline. For streaming output over pipelines, combine with e (each) to print one element per line. Gotcha: say always adds a newline — if you need raw output without one, use print instead.

p "hello world"
my @names = ("alice", "bob", "eve")
@names |> e p
1:5 |> maps { _ * 2 } |> e p

# printf

Formatted print to a filehandle (default STDOUT), using C-style format specifiers. The first argument is the format string with %s (string), %d (integer), %f (float), %x (hex), %o (octal), %e (scientific), %g (general float), and %% (literal percent). Width and precision modifiers work as in C: %-10s left-aligns in a 10-char field, %05d zero-pads to 5 digits, %.2f gives 2 decimal places. In stryke, printf supports all standard Perl 5 format specifiers including %v (version strings) and %n is disabled for safety. Direct output to a handle by placing it before the format: printf STDERR "...", @args. Unlike sprintf, printf outputs directly and returns a boolean indicating success.

printf "%-10s %5d\n", $name, $score
printf STDERR "error %d: %s\n", $code, $msg
printf "%08.2f\n", 3.14159   # 00003.14
printf "%s has %d item%s\n", $user, $n, $n == 1 ? "" : "s"

# sprintf

Return a formatted string without printing it, using the same C-style format specifiers as printf. This is the go-to function for building formatted strings for later use — constructing log messages, building padded table columns, converting numbers to hex or binary representations, or assembling strings that will be passed to other functions. In stryke, sprintf is often combined with the pipe operator: $val |> t { sprintf "0x%04x", _ } |> p. The return value is always a string. All format specifiers from printf apply here.

my $hex = sprintf "0x%04x", 255
my $padded = sprintf "%08d", $id
my $msg = sprintf "%-20s: %s", $key, $value
my @rows = map { sprintf "%3d. %s", _, $names[_] } 0..$ #names
@rows |> e p

# slurp

Read an entire file into memory as a single UTF-8 string. The short alias sl is convenient in pipelines. Dies if the file does not exist or cannot be read. This is the complement of spurt/wf — together they form a simple read/write pair for whole-file operations. For binary data, use read_bytes/slurp_raw instead.

my $text = slurp("config.yaml")
p $text
my $json = sl("data.json")
my $data = decode_json($json)
"README.md" |> sl |> length |> p  # character count

# slurp_raw

Read an entire file into memory as raw bytes without any encoding interpretation. Unlike slurp, which returns a decoded UTF-8 string, read_bytes preserves the exact byte content — useful for binary files like images, compressed archives, or protocol buffers. The alias slurp_raw emphasizes the raw nature.

my $png = read_bytes("logo.png")
p length($png)                        # byte count
my $gz = slurp_raw("data.gz")
my $text = gunzip($gz)
p $text

# input

Slurp all of stdin (or a filehandle) as one string.

my $all = input          # slurp stdin
my $fh_data = input($fh) # slurp filehandle

# read_lines

Read a file and return its contents as a list of lines with trailing newlines stripped. This is the idiomatic way to slurp a file line-by-line in stryke without manually opening a filehandle. The short alias rl keeps one-liners concise. If the file does not exist, the program dies with an error message.

my @lines = rl("data.txt")
p scalar @lines               # line count
@lines |> grep /ERROR/ |> e p # print error lines
my $first = (rl "config.ini")[0]$1

Note: returns an empty list for an empty file.

# append_file

Append a string to the end of a file, creating it if it does not exist. This is the safe way to add content without overwriting — useful for log files, CSV accumulation, or incremental output. The short alias af is convenient in pipelines. The file is opened, written, and closed atomically per call.

af("log.txt", "started at " . datetime_utc() . "\n")
1:5 |> e { af("nums.txt", "_\n") }
my @data = ("a","b","c")
@data |> e { af "out.txt", "_\n" }

# to_file

Write a string to a file, truncating any existing content. Unlike append_file, this replaces the file entirely. Returns the written content so it can be used in a pipeline — write to disk and continue processing in one expression. Creates the file if it does not exist.

my $csv = "name,age\nAlice,30\nBob,25"
$csv |> to_file("people.csv") |> p
to_file("empty.txt", "")  # truncate a file

Note: the return-value-for-piping behavior distinguishes this from a plain write.

# write

Output a formatted record to a filehandle using a format declaration. write looks up the format associated with the current (or specified) filehandle, evaluates the format's picture lines against the current variables, and outputs the result. This is Perl's original report-generation mechanism, predating modules like Text::Table and template engines. In stryke, write and format are supported for backward compatibility but are rarely used in new code — printf/sprintf or template strings are more flexible. The format name defaults to the filehandle name (e.g., format STDOUT is used by write STDOUT).

format STDOUT =
@<<<<<<<<<< @>>>>>>
$name,       $score
.

my ($name, $score) = ("alice", 42)
write   # outputs: alice           42

# write_file

Write a string to a file, creating it if it does not exist or truncating it if it does. This is the complement of slurp — together they form a read/write pair for whole-file operations. The short alias wf is convenient for one-liners. The file is opened, written, and closed in a single call.

spurt("hello.txt", "Hello, world!\n")
wf("nums.txt", join("\n", 1:10))
"generated content" |> wf("out.txt")
my $data = slurp("in.txt")
wf("copy.txt", $data)

# write_json

Serialize a stryke data structure (hash ref or array ref) as pretty-printed JSON and write it to a file. Creates or overwrites the target file. The short alias wj pairs with rj for round-trip JSON workflows. Useful for persisting configuration, caching API responses, or generating fixture data.

my %data = (name => "Alice", scores => [98, 87, 95])
wj("out.json", \%data)
my $back = rj("out.json")
p $back->{name}   # Alice

# read_json

Read a JSON file from disk and parse it into a stryke data structure (hash ref or array ref). The short alias rj keeps JSON-config one-liners terse. Dies if the file does not exist or contains malformed JSON. This is the complement of write_json/wj.

my $cfg = rj("config.json")
p $cfg->{database}{host}
my @items = @{ rj("list.json") }
@items |> e { p _->{name} }$1

Note: numeric strings remain strings; use `+0` to coerce if needed.

# tempfile

Create a temporary file in the system temp directory and return its absolute path as a string. The file is created with a unique name and exists on disk immediately. Use tf as a short alias for quick scratch files in one-liners. The caller is responsible for cleanup, though OS temp-directory reaping will eventually reclaim it.

my $tmp = tf()
to_file($tmp, "scratch data\n")
p rl($tmp)           # scratch data
my @all = map { tf() } 1:3  # three temp files

# tempdir

Create a temporary directory in the system temp directory and return its absolute path. The directory is created with a unique name and is ready for use immediately. The short alias tdr mirrors tf for files. Useful for isolating multi-file operations like test fixtures, build artifacts, or staged output.

my $dir = tdr()
to_file("$dir/a.txt", "hello")
to_file("$dir/b.txt", "world")
my @files = glob("$dir/*.txt")
p scalar @files   # 2

# binmode

Set the I/O layer on a filehandle, controlling how bytes are translated during reads and writes. Without a layer argument, binmode $fh switches the handle to raw binary mode (no CRLF translation on Windows, no encoding transforms). With a layer, binmode $fh, ':utf8' enables UTF-8 decoding, binmode $fh, ':raw' strips all layers for pure byte I/O, and binmode $fh, ':encoding(ISO-8859-1)' sets a specific encoding. In stryke, encoding layers can also be specified directly in open: open my $fh, '<:utf8', $path. Call binmode before any I/O on the handle — calling it mid-stream may produce garbled output. For binary file processing (images, archives, network protocols), always use :raw.

open my $fh, '<', $path or die $!
binmode $fh, ':utf8'
my @lines = <$fh>

open my $bin, '<', $img_path or die $!
binmode $bin, ':raw'
read $bin, my $header, 8
p sprintf "magic: %s", unpack("H*", $header)

# fileno

Return the underlying OS file descriptor number for a filehandle, or undef if the handle is not connected to a real file descriptor (e.g., tied handles, in-memory handles opened to scalar refs). File descriptor numbers are small non-negative integers managed by the OS kernel: 0 is STDIN, 1 is STDOUT, 2 is STDERR. This function is mainly useful for interfacing with system calls that require raw fd numbers, checking whether two handles share the same underlying fd, or passing descriptors to child processes. In stryke, fileno is rarely needed in everyday code but is essential for low-level I/O multiplexing and process management.

my $fd = fileno STDOUT
p "stdout fd: $fd"   # 1

if (defined fileno $fh) {
    p "handle is backed by fd " . fileno($fh)
} else {
    p "not a real file descriptor"
}

# flock

Advisory file locking for coordinating access between processes. flock $fh, OPERATION where OPERATION is LOCK_SH (shared/read lock), LOCK_EX (exclusive/write lock), or LOCK_UN (unlock). Add LOCK_NB for non-blocking mode: LOCK_EX | LOCK_NB returns false immediately if the lock is held rather than waiting. Import constants from Fcntl. Advisory locks are cooperative — they only work if all processes accessing the file use flock. In stryke, flock is the standard mechanism for safe concurrent file access in multi-process scripts, cron jobs, and daemons. Always unlock explicitly or let the handle close (which releases the lock). Gotcha: flock does not work on NFS on many systems.

use Fcntl ':flock'
open my $fh, '>>', 'shared.log' or die $!
flock $fh, LOCK_EX or die "lock: $!"
print $fh tm "pid $$ wrote this\n"
flock $fh, LOCK_UN
close $fh

unless (flock $fh, LOCK_EX | LOCK_NB) {
    p "file is locked by another process"
}

# getc

Read a single character from a filehandle (default STDIN). Returns undef at EOF. The character returned respects the handle's encoding layer — under :utf8, getc returns a full Unicode character which may be multiple bytes on disk. This function is useful for interactive single-key input, parsing binary formats one byte at a time, or implementing character-level tokenizers. In stryke, getc blocks until a character is available on the handle. For terminal input, note that most terminals are line-buffered by default, so getc STDIN won't return until the user presses Enter unless you put the terminal into raw mode.

my $ch = getc STDIN
p "you pressed: $ch"

open my $fh, '<:utf8', $path or die $!
while (defined(my $c = getc $fh)) {
    p "char: $c (ord " . ord($c) . ")"
}

# select

In its one-argument form, select HANDLE sets the default output handle for print, say, and write, returning the previously selected handle. This is useful for temporarily redirecting output — for example, sending diagnostics to STDERR while a report goes to a file. In its four-argument form, select RBITS, WBITS, EBITS, TIMEOUT performs POSIX select(2) I/O multiplexing, waiting for one or more file descriptors to become ready for reading, writing, or to report exceptions. The four-argument form is low-level and rarely used directly in stryke — prefer IO::Select or async I/O patterns for multiplexing. select with $| is also the classic way to enable autoflush on a handle.

my $old = select STDERR
p "this goes to stderr"
select $old

# Enable autoflush on STDOUT
select STDOUT; $| = 1
print "immediately flushed"

# truncate

Truncate a file to a specified byte length. Accepts either a filehandle or a filename as the first argument, and the desired length as the second. truncate $fh, 0 empties the file entirely — a common pattern when rewriting a file in place. truncate $fh, $len discards everything beyond byte $len. Returns true on success, false on failure (check $! for the error). In stryke, truncate works on any seekable filehandle. When using truncate to rewrite a file, remember to also seek $fh, 0, 0 to rewind the write position — truncating does not move the file pointer. Gotcha: truncating a file opened read-only will fail.

open my $fh, '+<', 'data.txt' or die $!
truncate $fh, 0       # empty the file
seek $fh, 0, 0        # rewind to start
print $fh "fresh content\n"
close $fh

# sysopen

Low-level open using POSIX flags for precise control over how a file is opened. The signature is sysopen FH, FILENAME, FLAGS [, PERMS]. Flags are bitwise-OR combinations from Fcntl: O_RDONLY, O_WRONLY, O_RDWR, O_CREAT, O_EXCL, O_TRUNC, O_APPEND, O_NONBLOCK, and others. The optional PERMS argument (e.g., 0644) sets the file mode when O_CREAT creates a new file, subject to the process umask. sysopen is the right tool when you need O_EXCL for atomic file creation (lock files, temp files), O_NONBLOCK for non-blocking I/O, or other flags that open cannot express. In stryke, prefer three-argument open for routine file access and reserve sysopen for cases requiring specific POSIX semantics.

use Fcntl
# Atomic create — fails if file already exists
sysopen my $lock, '/tmp/my.lock', O_WRONLY|O_CREAT|O_EXCL, 0644
    or die "already running: $!"
print $lock $$

sysopen my $log, 'app.log', O_WRONLY|O_APPEND|O_CREAT, 0644
    or die "open log: $!"

# sysread

Low-level unbuffered read directly from a file descriptor, bypassing PerlIO buffering layers. The signature is sysread FH, SCALAR, LENGTH [, OFFSET]. Returns the number of bytes read, 0 at EOF, or undef on error. Unlike read, sysread issues a single read(2) system call and may return fewer bytes than requested (short read). This is the right choice for sockets, pipes, and non-blocking I/O where you need precise control over how many system calls occur and cannot tolerate buffering. In stryke, never mix sysread/syswrite with buffered I/O (print, read, <$fh>) on the same handle — the buffered and unbuffered positions will diverge and produce corrupted reads.

open my $fh, '<:raw', $path or die $!
my $buf = ''
while (my $n = sysread $fh, $buf, 4096, length($buf)) {
    p "read $n bytes (total: " . length($buf) . ")"
}
close $fh

# syswrite

Low-level unbuffered write directly to a file descriptor, bypassing PerlIO buffering layers. The signature is syswrite FH, SCALAR [, LENGTH [, OFFSET]]. Returns the number of bytes actually written, which may be less than requested on non-blocking handles or when writing to pipes/sockets (short write). Returns undef on error. Like sysread, this issues a single write(2) system call and must not be mixed with buffered I/O on the same handle. In stryke, syswrite is essential for socket programming, IPC, and performance-critical binary output where you need to avoid double-buffering. Always check the return value and handle short writes in a loop for robust code.

my $data = "hello, world"
my $n = syswrite $fh, $data
p "wrote $n bytes"

# Robust write loop for sockets
my $off = 0
while ($off < length $data) {
    my $written = syswrite $fh, $data, length($data) - $off, $off
    die "syswrite: $!" unless defined $written
    $off += $written
}

# sysseek

Low-level seek on a file descriptor, bypassing PerlIO buffering. The signature is sysseek FH, POSITION, WHENCE with the same WHENCE values as seek (0=start, 1=current, 2=end). Returns the new position as a true value, or undef on failure. Unlike seek, sysseek does not flush PerlIO buffers — it operates directly on the underlying OS file descriptor. Use sysseek when working with sysread/syswrite for consistent positioning. In stryke, sysseek with SEEK_CUR and position 0 is an idiom for querying the current fd position without moving: my $pos = sysseek $fh, 0, 1.

sysseek $fh, 0, 0   # rewind to start
sysread $fh, my $buf, 512

my $pos = sysseek $fh, 0, 1
p "fd position: $pos"

# format

Declare a picture-format template for generating fixed-width text reports. The syntax is format NAME = ... . where each line alternates between picture lines (containing field placeholders) and argument lines (listing the variables to fill in). Placeholders include @<<<< (left-align), @>>>> (right-align), @|||| (center), @###.## (numeric with decimal), and @* (multiline block fill). The format ends with a lone . on its own line. In stryke, formats are a legacy feature preserved for compatibility with Perl 5 code — for new reports, prefer printf/sprintf for simple alignment or a templating module for complex layouts. Formats interact with the special variables $~ (current format name), $^ (header format), and $= (lines per page).

format REPORT =
@<<<<<<<<<<<<<<<< @>>>>> @ ###.##
$item,            $qty,  $price
.

my ($item, $qty, $price) = ("Widget", 100, 9.99)
my $old = select REPORT
$~ = 'REPORT'
write REPORT
select $old

# formline

Format a line of output according to a picture template, appending the result to the $^A (format accumulator) variable. This is the low-level engine behind Perl's format/write report-generation system. Template characters like @<<< (left-justify), @>>> (right-justify), and @###.## (numeric) control field placement.

$^A = ""
formline("@<<<< @>>>>>\n", "Name", "Score")
formline("@<<<< @>>>>>\n", "Alice", 98)
formline("@<<<< @>>>>>\n", "Bob", 85)
p $^A

# chomp

chomp STRING — remove the trailing record separator (usually \n) from a string in place and return the number of characters removed.

chomp is the idiomatic way to strip newlines after reading input; unlike chop, it only removes the value of $/ (the input record separator), so it is safe to call on strings that do not end with a newline — it simply does nothing. You can also chomp an entire array to strip every element at once. In stryke, chomp operates on UTF-8 strings and respects multi-byte $/ values. Prefer chomp over chop in virtually all input-processing code; chop is only for when you truly need to remove an arbitrary trailing character regardless of what it is.

my $line = <STDIN>
chomp $line
p $line
chomp(my @lines = <$fh>)  # strip all at once
p scalar @lines

# chop

chop STRING — remove and return the last character of a string, modifying the string in place.

Unlike chomp, chop unconditionally removes whatever the final character is — newline, letter, digit, or even a multi-byte UTF-8 codepoint in stryke. The return value is the removed character. This makes chop useful for peeling off known trailing delimiters or building parsers that consume input character-by-character, but dangerous for general newline removal because it will silently eat a real character if the string does not end with \n. When called on an array, chop removes the last character of every element and returns the last one removed.

my $s = "hello!"
my $last = chop $s  # $last = "!", $s = "hello"
p $s
my @words = ("foo\n", "bar\n")
chop @words  # strips trailing newline from each
@words |> e p

# length

length STRING — return the number of characters in a string, or the number of elements when given an array.

In string context, length counts Unicode characters, not bytes — so length "\x{1F600}" is 1 in stryke even though the emoji occupies 4 bytes in UTF-8. When passed an array, stryke returns the element count (equivalent to scalar @arr), which diverges slightly from Perl where length @arr stringifies the array first. This dual behavior is intentional in stryke for convenience. To get byte length instead of character length, use bytes::length or encode first. Always use length rather than comparing against the empty string when checking for non-empty input.

p length "hello"  # 5
my @a = (1:10)
p length @a       # 10
p length "\x{1F600}"  # 1 (single emoji codepoint)

# substr

substr STRING, OFFSET [, LENGTH [, REPLACEMENT]] — extract or replace a substring.

substr is stryke's Swiss-army knife for positional string manipulation. With two arguments it extracts from OFFSET to end; with three it extracts LENGTH characters; with four it replaces that range with REPLACEMENT and returns the original extracted portion. Negative OFFSET counts from the end of the string (substr $s, -3 gives the last three characters). In stryke, offsets are UTF-8 character positions, making it safe for multi-byte text. substr as an lvalue (substr($s, 0, 1) = "X") is also supported for in-place mutation. Prefer substr over regex when you know exact positions — it is faster and clearer.

my $s = "hello world"
p substr $s, 0, 5              # hello
p substr $s, -5                # world
substr $s, 6, 5, "stryke"     # $s = "hello stryke"
p $s

# index

index STRING, SUBSTRING [, POSITION] — return the zero-based position of the first occurrence of SUBSTRING within STRING, or -1 if not found.

The optional POSITION argument lets you start the search at a given offset, which is essential for scanning forward through a string in a loop (call index repeatedly, advancing POSITION past each hit). In stryke, index operates on UTF-8 character positions, not byte offsets, so it is safe for multi-byte strings. For finding the *last* occurrence, use rindex instead. A common pattern is pairing index with substr to extract fields from fixed-format data without the overhead of a regex or split.

my $i = index "hello world", "world"  # 6
p $i
my $s = "a.b.c.d"
my $pos = 0
while (($pos = index $s, ".", $pos) != -1) {
    p "dot at $pos"
    $pos++
}

# rindex

rindex STRING, SUBSTRING [, POSITION] — return the zero-based position of the last occurrence of SUBSTRING within STRING, searching backward from POSITION (or the end).

rindex mirrors index but searches from right to left, making it ideal for extracting file extensions, final path components, or the last delimiter in a string. The optional POSITION argument caps how far right the search begins — characters after POSITION are ignored. Returns -1 when the substring is not found. In stryke, positions are UTF-8 character offsets. Combine with substr for efficient right-side extraction without regex.

my $path = "foo/bar/baz.tar.gz"
my $i = rindex $path, "/"     # 7
p substr $path, $i + 1        # baz.tar.gz
my $ext = rindex $path, "."   # 15
p substr $path, $ext + 1      # gz

# split

split /PATTERN/, STRING [, LIMIT] — divide STRING into a list of substrings by splitting on each occurrence of PATTERN.

split is one of the most-used string functions. The PATTERN is a regex, so you can split on character classes, alternations, or lookaheads. A LIMIT caps the number of returned fields; the final field contains the unsplit remainder. The special pattern " " (a single space string, not regex) mimics awk-style splitting: it strips leading whitespace and splits on runs of whitespace. In stryke, split integrates with |> pipelines, accepting piped-in strings for ergonomic one-liners. Trailing empty fields are removed by default; pass -1 as LIMIT to preserve them.

my @parts = split /,/, "a,b,c"
"one:two:three" |> split /:/ |> e p   # one two three
my ($user, $domain) = split /@/, $email, 2
p "$user at $domain"

# join

join SEPARATOR, LIST — concatenate all elements of LIST into a single string, placing SEPARATOR between each pair of adjacent elements.

join is the inverse of split. It stringifies each element before joining, so mixing numbers and strings is fine. An empty separator (join "", @list) concatenates without gaps. In stryke, join works naturally with |> pipelines: a range or filtered list can be piped directly into join with a separator argument. This is the standard way to build CSV lines, path strings, or human-readable lists from arrays. join never adds a trailing separator — if you need one, append it yourself.

my $csv = join ",", @fields
1:5 |> join "-" |> p   # 1-2-3-4-5
my @parts = ("usr", "local", "bin")
p join "/", "", @parts   # /usr/local/bin

# uc

uc STRING — return a fully uppercased copy of the string.

uc performs Unicode-aware uppercasing in stryke, correctly handling multi-byte characters and locale-sensitive transformations. It returns a new string without modifying the original. Use uc for normalizing strings before comparison, formatting headers, or transforming pipeline output. In stryke |> chains, combine with maps or t for streaming uppercase transforms. For uppercasing only the first character (e.g., sentence capitalization), use ucfirst instead.

p uc "hello"  # HELLO
@words |> maps { uc } |> e p
"whisper" |> t uc |> p   # WHISPER

# lc

lc STRING — return a fully lowercased copy of the string.

lc performs Unicode-aware lowercasing in stryke, so lc "\x{C4}" (capital A with diaeresis) correctly returns the lowercase form. It does not modify the original string — it returns a new one. This is the standard way to normalize strings for case-insensitive comparison: if (lc $a eq lc $b). In stryke |> pipelines, wrap lc with t to apply it as a streaming transform. For lowercasing only the first character, use lcfirst instead.

p lc "HELLO"               # hello
"SHOUT" |> t lc |> t rev |> p  # tuohs
my @norm = map lc, @words
@norm |> e p

# ucfirst

ucfirst STRING — return a copy of the string with only the first character uppercased, leaving the rest unchanged.

This is the standard way to capitalize the first letter of a word for display, title-casing, or converting camelCase to PascalCase. In stryke, ucfirst is Unicode-aware and correctly handles multi-byte leading characters. It returns a new string and does not modify the original. For full uppercasing, use uc. A common idiom is ucfirst lc $word to normalize a word to "Title" form.

p ucfirst "hello"            # Hello
p ucfirst lc "hELLO"         # Hello
my @titled = map { ucfirst lc } @raw
@titled |> join " " |> p

# lcfirst

lcfirst STRING — return a copy of the string with only the first character lowercased, leaving the rest unchanged.

This is useful for converting PascalCase identifiers to camelCase, or for formatting output where only the initial letter matters. In stryke, lcfirst is Unicode-aware, so it handles accented capitals and multi-byte first characters correctly. Like lc, it returns a new string rather than modifying in place. If you need the entire string lowercased, use lc instead.

p lcfirst "Hello"    # hello
p lcfirst "XMLParser" # xMLParser
my @camel = map lcfirst, @PascalNames
@camel |> e p

# chr

chr NUMBER — return the character represented by the given ASCII or Unicode code point.

chr is the inverse of ord: chr(ord($c)) eq $c always holds. It accepts any non-negative integer and returns a single-character string. In stryke, values above 127 produce valid UTF-8 characters, so chr 0x1F600 gives you a smiley emoji with no special encoding gymnastics. For string literals, stryke supports all standard escapes: \x{hex}, \u{hex}, \o{oct}, \NNN (octal), \cX (control), \N{U+hex}, \N{UNICODE NAME}, plus case modifiers \U..\E, \L..\E, \u, \l, \Q..\E.

p chr 65       # A
p chr 0x1F600  # smiley emoji
p "\u{0301}"   # combining acute accent
p "\N{SNOWMAN}" # ☃
my @abc = map { chr(_ + 64) } 1:26
@abc |> join "" |> p  # ABCDEFGHIJKLMNOPQRSTUVWXYZ

# ord

ord STRING — return the numeric (Unicode code point) value of the first character of the string.

ord is the inverse of chr: ord(chr($n)) == $n always holds. When passed a multi-character string, only the first character is examined — the rest are ignored. In stryke, ord returns the full Unicode code point, not just 0-255, so ord "\u{1F600}" returns 128512. This is useful for character classification, building lookup tables, or implementing custom encodings. For ASCII checks, ord($c) >= 32 && ord($c) <= 126 tests printability.

p ord "A"          # 65
p ord "\n"         # 10
p ord "\u{1F600}"  # 128512
my @codes = map ord, split //, "hello"
@codes |> e p      # 104 101 108 108 111

# hex

hex STRING — interpret a hexadecimal string and return its numeric value.

The leading 0x prefix is optional: both hex "ff" and hex "0xff" return 255. The string is case-insensitive, so hex "DeAdBeEf" works fine. If the string contains non-hex characters, stryke warns and converts up to the first invalid character. This is the standard way to parse hex-encoded values from config files, color codes, or protocol dumps. For the reverse operation (number to hex string), use sprintf "%x". Note that hex always returns a number, never a string — arithmetic is immediate.

my $n = hex "deadbeef"
printf "0x%x = %d\n", $n, $n
p hex "ff"   # 255
"cafe" |> t { hex } |> p   # 51966

# oct

oct STRING — interpret an octal, hexadecimal, or binary string and return its numeric value.

oct is the multi-base cousin of hex: it auto-detects the base from the prefix. Strings starting with 0b are binary, 0x are hex, and bare digits or 0-prefixed digits are octal. This makes it the go-to for parsing Unix file permissions (oct "0755" gives 493), binary literals, or any string where the radix is embedded in the value. In stryke, oct handles arbitrarily large integers via the same big-number pathway as other arithmetic. A common gotcha: oct "8" warns because 8 is not a valid octal digit — use hex or a bare numeric literal instead.

p oct "0755"    # 493
p oct "0b1010"  # 10
p oct "0xff"    # 255
my $perms = oct "644"
p sprintf "%04o", $perms  # 0644

# quotemeta

quotemeta STRING — escape all non-alphanumeric characters with backslashes, returning a string safe for interpolation into a regex.

This is essential when building dynamic regexes from user input: without quotemeta, characters like ., *, (, ), [, and \ would be interpreted as regex metacharacters, leading to either broken patterns or security vulnerabilities (ReDoS). The equivalent inline syntax is \Q..\E inside a regex. In stryke, quotemeta handles the full Unicode range, escaping any character that is not [A-Za-z0-9_]. Use it liberally whenever you splice user-provided strings into patterns.

my $input = "file (1).txt"
my $safe = quotemeta $input
p $safe  # file\ \(1\)\.txt
my $found = ("file (1).txt" =~ /^$safe$/)
p $found  # 1

# trim

trim STRING or trim LIST — strip leading and trailing ASCII whitespace.

When given a single string, trim returns the stripped result. When given a list or used in a pipeline, it operates in streaming mode, trimming each element individually as it flows through. Whitespace includes spaces, tabs, carriage returns, and newlines. The tm alias is convenient in pipeline chains where brevity matters.

" hello " |> tm |> p                  # "hello"
@raw |> tm |> e p
slurp("data.csv") |> ln |> tm |> e p

# lines

lines STRING / ln STRING — split a string on newline boundaries, returning a streaming iterator of lines.

Each line is yielded without the trailing newline character. When piped from slurp, this gives you a lazy line-by-line view of a file without loading all lines into memory at once. Both \n and \r\n line endings are handled. The ln alias keeps pipelines compact.

slurp("data.txt") |> lines |> e p
my @rows = lines $multiline_str
$body |> ln |> grep /TODO/ |> e p

# words

words (alias wd) splits a string on whitespace boundaries and returns the resulting list of words. It handles leading, trailing, and consecutive whitespace gracefully — unlike a naive split / /, it never produces empty strings. This is the idiomatic way to tokenize a line of text in stryke, and the short alias wd keeps pipelines compact. It is equivalent to Perl's split ' ' behavior.

my @w = wd "  hello   world  "
p @w       # hello, world
my $line = "  foo  bar  baz  "
my $count = scalar wd $line
p $count   # 3
rl("data.txt") |> map { scalar wd _ } |> e p

# chars

chars STRING / ch STRING — split a string into individual characters, returning a streaming iterator.

Each Unicode grapheme cluster is yielded as a separate string element. This is useful for character-level processing such as frequency counting, transliteration, or building character n-grams. In pipeline mode the characters stream one at a time, so you can chain with take, grep, or with_index without materializing the full character array.

"hello" |> chars |> e p               # h e l l o
my @c = chars "abc"
"emoji: \x{1F600}" |> ch |> e p

# snake_case

snake_case (alias sc) converts a string from any common casing convention — camelCase, PascalCase, kebab-case, or mixed — into snake_case, where words are lowercase and separated by underscores. This is the standard naming convention for Perl and Rust variables and function names. Consecutive uppercase letters in acronyms are handled intelligently (e.g., parseHTTPResponse becomes parse_http_response).

p sc "camelCase"          # camel_case
p sc "PascalCase"         # pascal_case
p sc "kebab-case"         # kebab_case
p sc "parseHTTPResponse"  # parse_http_response
my @methods = qw(getUserName setEmailAddr)
@methods |> map sc |> e p

# camel_case

camel_case (alias cc) converts a string from any casing convention into camelCase, where the first word is lowercase and subsequent words are capitalized with no separators. This is the standard naming convention for JavaScript variables and Java methods. The function handles underscores, hyphens, and spaces as word boundaries and strips them during conversion.

p cc "snake_case"         # snakeCase
p cc "kebab-case"         # kebabCase
p cc "PascalCase"         # pascalCase
p cc "hello world"        # helloWorld
my @cols = qw(first_name last_name email_addr)
@cols |> map cc |> e p

# kebab_case

kebab_case (alias kc) converts a string from any casing convention into kebab-case, where words are lowercase and separated by hyphens. This is the standard naming convention for CSS classes, URL slugs, and CLI flag names. Like snake_case, it intelligently handles acronyms and mixed-case input. The function treats underscores, spaces, and case transitions as word boundaries.

p kc "camelCase"          # camel-case
p kc "PascalCase"         # pascal-case
p kc "snake_case"         # snake-case
p kc "parseHTTPResponse"  # parse-http-response
my $slug = kc $title      # URL-safe slug

# study

study STRING — hint to the regex engine that the given string will be matched against multiple patterns, allowing it to build an internal lookup table for faster matching.

In classic Perl, study builds a linked list of character positions so subsequent regex matches can skip impossible starting points. In practice, modern regex engines (including stryke's Rust-based engine) already perform these optimizations internally, so study is effectively a no-op in stryke — calling it is harmless but provides no measurable speedup. It exists for compatibility with Perl code that uses it. You only need study when porting legacy scripts that call it; do not add it to new stryke code expecting a performance benefit.

study $text   # no-op in stryke, kept for compatibility
my @hits = grep { /$pattern/ } @lines
p scalar @hits

# pos

pos SCALAR — gets or sets the position where the next m//g (global match) will start searching in the given string. After a successful m//g match, pos returns the offset just past the end of the match. You can assign to pos($s) to manually reposition the search. If the last m//g failed, pos resets to undef. This is essential for writing lexers or tokenizers that consume a string incrementally with \G-anchored patterns. In stryke, pos tracks per-scalar state just like Perl.

my $s = "abcabc"
while ($s =~ /a/g) { p pos($s) }
# 1 4
pos($s) = 0   # reset to scan again
p pos($s)     # 0

# push

push @array, LIST — appends one or more elements to the end of an array and returns the new length. This is the primary way to grow arrays in stryke and works identically to Perl's builtin. You can push scalars, lists, or even the result of a pipeline. In stryke, push is O(1) amortized thanks to the underlying Rust Vec.

my @q
push @q, 1:3
push @q, "four", "five"
p scalar @q   # 5
@q |> e p     # 1 2 3 four five

Returns the new element count, so my $len = push @arr, $val; is valid.

# pop

pop @array — removes and returns the last element of an array, or undef if the array is empty. This is the complement of push and together they give you classic stack (LIFO) semantics. In stryke the operation is O(1) because the underlying Rust Vec::pop simply decrements the length. When called without an argument inside a subroutine, pop operates on @_; at file scope it operates on @ARGV, matching standard Perl behavior.

my @stk = 1:5
my $top = pop @stk
p $top          # 5
p scalar @stk   # 4
@stk |> e p     # 1 2 3 4

# shift

shift @array — removes and returns the first element of an array, sliding all remaining elements down by one index. Like pop, it returns undef on an empty array. Without an explicit argument it defaults to @_ inside subroutines and @ARGV at file scope. Because every element must be moved, shift is O(n); if you only need LIFO access, prefer push/pop. Use shift when processing argument lists or implementing FIFO queues.

my @args = @ARGV
my $cmd = shift @args
p $cmd
@args |> e p   # remaining arguments

# unshift

unshift @array, LIST — prepends one or more elements to the beginning of an array and returns the new length. It is the counterpart of push for the front of the array. Like shift, this is O(n) because existing elements must be moved to make room. When you need to build an array in reverse order or maintain a priority queue with newest items first, unshift is the idiomatic choice. You can pass multiple values and they will appear in the same order they were given.

my @log = ("b", "c")
unshift @log, "a"
@log |> e p   # a b c
my $len = unshift @log, "x", "y"
p $len        # 5
@log |> e p   # x y a b c

# splice

splice @array, OFFSET [, LENGTH [, LIST]] — the Swiss-army knife for array mutation. It can insert, remove, or replace elements at any position in a single call. With just an offset it removes everything from that point to the end. With offset and length it removes that many elements. With a replacement list it inserts those elements in place of the removed ones. The return value is the list of removed elements, which is useful for saving what you cut. In stryke this compiles down to Rust's Vec::splice and Vec::drain.

my @a = 1:5
my @removed = splice @a, 1, 2, 8, 9
@a |> e p        # 1 8 9 4 5
@removed |> e p  # 2 3
splice @a, 2     # remove from index 2 onward
@a |> e p        # 1 8

# keys

keys %hash — returns the list of all keys in a hash in no particular order. When called on an array, it returns the list of valid indices (0 to $#array). In scalar context, keys returns the number of keys. Calling keys resets the each iterator on that hash, which is the standard way to restart iteration. In stryke, this calls Rust's HashMap::keys() and collects into a Vec. For sorted output, chain with sort via the pipe operator.

my %env = (HOME => "/root", USER => "me")
keys(%env) |> sort |> e p   # HOME USER
p scalar keys %env           # 2
my @a = (10, 20, 30)
keys(@a) |> e p              # 0 1 2

# values

values %hash — returns the list of all values in a hash in no particular order (matching the order of keys for the same hash state). When called on an array, it returns the array elements themselves. In scalar context, returns the count of values. Like keys, calling values resets the each iterator. In stryke this maps to Rust's HashMap::values(). Combine with sum, sort, or pipeline operators for common aggregation patterns.

my %scores = (alice => 90, bob => 85)
p sum(values %scores)   # 175
values(%scores) |> sort { $_1 <=> $_0 } |> e p   # 90 85

# each

each %hash — returns the next (key, value) pair from a hash as a two-element list, or an empty list when the iterator is exhausted. Each hash has its own internal iterator, which is reset when you call keys or values on the same hash. This is memory-efficient for large hashes because it does not build the full key list. Gotcha: do not add or delete keys while iterating with each; that can cause skipped or duplicated entries. In stryke, the iteration order is non-deterministic (Rust HashMap order).

my %h = (a => 1, b => 2, c => 3)
while (my ($k, $v) = each %h) { p "$k=$v" }
# output order varies: a=1 b=2 c=3

# delete

delete EXPR — removes a key-value pair from a hash or an element from an array and returns the removed value (or undef if it did not exist). For hashes this is the only way to truly remove a key; assigning undef to $h{key} leaves the key in place. For arrays, delete sets the element to undef but does not shift indices (use splice if you need to close the gap). In stryke, hash deletion maps to Rust's HashMap::remove. You can delete multiple keys at once with a hash slice: delete @h{@keys}.

my %h = (x => 1, y => 2, z => 3)
my $old = delete $h{x}
p $old   # 1
p exists $h{x} ? "yes" : "no"   # no
delete @h{"y", "z"}   # delete multiple keys

# exists

exists EXPR — tests whether a specific key is present in a hash or an index is present in an array, regardless of whether the associated value is undef. This is different from defined: a key can exist but hold undef. Use exists to check hash membership before accessing a value to avoid autovivification side effects. In stryke, exists on a hash compiles to Rust's HashMap::contains_key, and on an array it checks bounds. You can also use it with nested structures: exists $h{a}{b} only checks the final level.

my %h = (a => 1, b => undef)
p exists $h{b} ? "yes" : "no"   # yes (key present, value undef)
p exists $h{c} ? "yes" : "no"   # no
my @a = (10, 20, 30)
p exists $a[5] ? "yes" : "no"   # no

# scalar

scalar EXPR — forces the expression into scalar context. The most common use is scalar @array to get the element count instead of the list of elements. In stryke, scalar context on an array returns its length as a Rust usize. You can also use scalar on a hash to get the number of key-value pairs, or on a function call to force it to return a single value. This is essential when you want a count inside string interpolation or as a function argument where list context would be ambiguous.

my @items = ("a", "b", "c")
p scalar @items   # 3
p "count: " . scalar @items   # count: 3
my %h = (x => 1, y => 2)
p scalar %h       # 2

# defined

defined EXPR — returns true if the expression has a value that is not undef. This is the canonical way to distinguish between "no value" and "a value that happens to be false" (such as 0, "", or "0"). Use defined before dereferencing optional values or checking return codes from functions that return undef on failure. In stryke, defined compiles to a Rust Option::is_some() check internally. Note that defined on an aggregate (hash or array) is deprecated in Perl 5 and is a no-op in stryke.

my $x = undef
p defined($x) ? "yes" : "no"   # no
$x = 0
p defined($x) ? "yes" : "no"   # yes
my $val = fn_that_may_fail()
p $val if defined $val

# undef

undef — the undefined value, representing the absence of a value. As a function, undef $var explicitly undefines a variable, freeing any value it held. undef is falsy in boolean context and triggers "use of uninitialized value" warnings under use warnings. In stryke, undef maps to Rust's None in an Option type internally. Use undef to reset variables, signal missing return values, or clear hash entries without deleting the key.

my $x = 42
undef $x
p defined($x) ? "def" : "undef"   # undef
fn maybe { return undef if !@_
    return $_[0] }
p defined(maybe()) ? "got" : "nothing"   # nothing

# ref

ref EXPR — returns a string indicating the reference type of the value, or an empty string if it is not a reference. Common return values are SCALAR, ARRAY, HASH, CODE, REF, and Regexp. For blessed objects it returns the class name. Use ref to dispatch on data type or validate arguments in polymorphic functions. In stryke, ref inspects the Rust enum variant of the underlying value. Note that ref does not recurse; it only tells you the top-level type.

my $r = [1, 2, 3]
p ref($r)       # ARRAY
p ref(\%ENV)    # HASH
p ref(\&main)   # CODE
p ref(42)       # (empty string)

# bless

Associate a reference with a package name, turning it into an object of that class. The blessed reference can then have methods called on it via ->. The second argument defaults to the current package. This is the foundation of Perl's object system.

fn new($class, %args) {
    bless { %args }, $class
}
my $obj = new("Dog", name => "Rex", breed => "Lab")
p ref($obj)          # Dog
p $obj->{name}       # Rex

# tie

Bind a variable to an implementing class so that all accesses (read, write, delete, etc.) are intercepted by methods on that class. This is Perl's mechanism for transparent object-backed variables — tied hashes can be backed by a database, tied scalars can validate on assignment, etc. Use untie to remove the binding.

tie my %db, 'DB_File', 'cache.db'
$db{key} = "value"         # writes to disk
p $db{key}                  # reads from disk
untie %db

# prototype

Return the prototype string of a named function, or undef if the function has no prototype. Prototypes control how arguments are parsed at compile time — they influence context and reference-passing behavior. Useful for introspection and metaprogramming.

p prototype("CORE::push")     # \@@
p prototype("CORE::map")      # &@
fn greet($name) { p "hi $name" }
p prototype(\&greet)          # undef (signatures, no proto)

# wantarray

wantarray() — returns true if the current subroutine was called in list context, false in scalar context, and undef in void context. This lets a function adapt its return value to the caller's expectations. A common pattern is returning a list in list context and a count or reference in scalar context. In stryke, use fn to define subroutines and wantarray() inside them just like in Perl. Note that wantarray only reflects the immediate call site, not nested contexts.

fn ctx { wantarray() ? "list" : "scalar" }
my @r = ctx()
p $r[0]   # list
my $r = ctx()
p $r      # scalar
fn flexible { wantarray() ? (1, 2, 3) : 3 }
my @all = flexible()
p scalar @all   # 3
my $cnt = flexible()
p $cnt          # 3

# caller

caller [LEVEL] — returns information about the calling subroutine's context. In list context it returns (package, filename, line) for the given call-stack level (default 0, the immediate caller). With higher levels you can walk up the call stack for debugging or generating stack traces. In scalar context, caller returns just the package name. In stryke, caller works with fn-defined subroutines and integrates with the runtime's frame tracking. This is invaluable for building custom error reporters or trace utilities.

fn trace {
    my ($pkg, $f, $ln) = caller()
    p "$f:$ln"
}
trace()   # prints current file:line
fn deep {
    my ($pkg, $f, $ln) = caller(1)
    p "grandparent: $f:$ln"
}

# if

The fundamental conditional construct. Evaluates its condition in boolean context and executes the block if true. stryke supports both the block form if (COND) { BODY } and the postfix form EXPR if COND, which is idiomatic for single-statement guards. The condition can be any expression — numbers (0 is false), strings (empty and "0" are false), undef (false), and references (always true). Postfix if cannot have elsif/else — use the block form for multi-branch logic.

my $n = 42
if ($n > 0) { p "positive" }
p "big" if $n > 10          # postfix — clean one-liner
my $label = "even" if $n % 2 == 0
p "got: $n" if defined $n   # guard against undef

# elsif

Chain additional conditions after an if block without nesting. Each elsif is tested in order; the first one whose condition is true has its block executed, and the rest are skipped. There is no limit on the number of elsif branches. In stryke, prefer match for complex multi-branch dispatch since it supports pattern matching, destructuring, and guards — but elsif remains the right tool for simple linear condition chains. Note: it is elsif, not elseif or else if — the latter is a syntax error.

fn classify($n) {
    if    ($n < 0)   { "negative" }
    elsif ($n == 0)  { "zero" }
    elsif ($n < 10)  { "small" }
    elsif ($n < 100) { "medium" }
    else             { "large" }
}
1:200 |> map classify |> frequencies |> dd

# else

The final fallback branch of an if/elsif chain, executed when no preceding condition was true. Every if can have at most one else, and it must come last. For ternary-style expressions, use COND ? A : B instead of an if/else block — it composes better in |> pipes and assignments.

if ($n % 2 == 0) { p "even" }
else             { p "odd" }

# Ternary is often cleaner in pipes:
1:10 |> map { _ % 2 == 0 ? "even" : "odd" } |> e p

# unless

A negated conditional — executes the block when the condition is *false*. This reads more naturally than if (!COND) for guard clauses and early returns. stryke supports both block and postfix forms. Convention: use unless for simple negative guards; avoid unless with complex compound conditions, as double-negatives hurt readability. There is no unlessif — use if/elsif chains for multi-branch logic.

unless ($ENV{QUIET}) { p "verbose output" }
p "missing!" unless -e $path   # postfix guard
die "no input" unless @ARGV
return unless defined $val    # early return pattern

# for

Iterate over a list, binding each element to a loop variable (or _ by default). for and foreach are interchangeable keywords. The loop variable is automatically localized and aliases the original element — modifications to _ inside the loop mutate the list in-place. In stryke, for loops work with ranges, arrays, hash slices, and iterator results. For parallel iteration, see pfor; for pipeline-style processing, prefer |> e or |> map. C-style for (INIT; COND; STEP) is also supported.

for my $f (glob "*.txt") { p $f }
for (1:5) { p _ * 2 }            # _ is default
my @names = qw(alice bob carol)
for (@names) { _ = uc _ }         # mutates in-place
p join ", ", @names                 # ALICE, BOB, CAROL

# while

Loop that re-evaluates its condition before each iteration and continues as long as it is true. Commonly used for reading input line-by-line, polling, and indefinite iteration. The condition is tested in boolean context. while integrates naturally with the diamond operator <> for reading filehandles. The loop variable can be declared in the condition with my, scoping it to the loop body. Postfix form is also supported: EXPR while COND;.

while (my $line = <STDIN>) {
    $line |> tm |> p             # trim + print each line
}
my $i = 0
while ($i < 5) { p $i++ }    # counted loop
while (1) { last if done() }     # infinite loop with break

# until

Loop that continues as long as its condition is *false* — the logical inverse of while. Useful when the termination condition is more naturally expressed as a positive assertion ("keep going until X happens"). Supports both block and postfix forms. Prefer while with a negated condition if until makes the logic harder to read.

my $n = 1
until ($n > 1000) { $n *= 2 }
p $n   # 1024

my $tries = 0
until (connected()) {
    $tries++
    sleep 1
}
p "connected after $tries tries"

# do

Execute a block and return its value, or execute a file. As a block, do { ... } creates an expression scope — the last expression in the block is the return value, making it useful for complex initializations. As a file operation, do "file.pl" executes the file in the current scope and returns its last expression. Unlike require, do does not cache and re-executes on each call. do { ... } while (COND) creates a loop that always runs at least once.

my $val = do { my $x = 10
    $x ** 2 }   # 100
p $val
my $cfg = do "config.pl"               # load config
# do-while: body runs at least once
my $input
do { $input = readline(STDIN) |> tm } while ($input eq "")

# last

Immediately exit the innermost enclosing loop (equivalent to break in C/Rust). Execution continues after the loop. last LABEL can target a labeled outer loop to break out of nested loops. Works in for, foreach, while, until, and do-while. Does *not* work inside map, grep, or |> pipeline stages — use take, first, or take_while for early termination in functional contexts.

for (1:1_000_000) {
    last if _ > 5
    p _
}   # prints 1 2 3 4 5

OUTER: for my $i (1:10) {
    for my $j (1:10) {
        last OUTER if $i * $j > 50   # break both loops
    }
}

For pipeline early-exit: 1:1000 |> take_while { _ < 50 } |> e p.

# next

Skip the rest of the current loop iteration and jump to the next one. The loop condition (for while/until) or the next element (for for/foreach) is evaluated immediately. Like last, next supports labeled loops with next LABEL for skipping in nested loops. This is the primary tool for filtering within imperative loops. In stryke, consider grep/filter or |> reject for functional-style filtering instead.

for (1:10) {
    next if _ % 2        # skip odds
    p _
}   # 2 4 6 8 10

for my $file (glob "*") {
    next unless -f $file   # skip non-files
    next if $file =~ /^\./  # skip hidden
    p $file
}

# redo

Restart the current loop iteration from the top of the loop body *without* re-evaluating the loop condition or advancing to the next element. The loop variable retains its current value. This is a niche but powerful tool for retry logic within loops — when an iteration fails, redo lets you try again with the same input. Use sparingly, as it can create infinite loops if the retry condition never resolves. Always pair with a guard or counter. For automated retry with backoff, prefer retry { ... } times => N, backoff => 'exponential'.

for my $url (@urls) {
    my $body = eval { fetch($url) }
    if ($@) {
        warn "retry $url: $@"
        sleep 1
        redo   # try same URL again
    }
    p length($body)
}

# continue

A block attached to a for/foreach/while loop that executes after each iteration, even when next is called. Analogous to the increment expression in a C-style for loop. The continue block does *not* run when last or redo is used. Useful for unconditional per-iteration bookkeeping like incrementing counters, logging progress, or flushing buffers. Rarely used but fully supported in stryke.

my $count = 0
for my $item (@work) {
    next if $item->{skip}
    process($item)
} continue {
    $count++
    p "processed $count so far" if $count % 100 == 0
}

# given

A switch-like construct that evaluates an expression and dispatches to when blocks via smartmatch semantics. The topic variable _ is set to the given expression for the duration of the block. Each when clause is tested in order; the first match executes its block and control passes out of the given (implicit break). A default block handles the no-match case. In stryke, prefer the match keyword for new code — it offers pattern destructuring, typed patterns, array/hash shape matching, and if guards that given/when cannot express.

given ($cmd) {
    when ("start")   { p "starting up" }
    when ("stop")    { p "shutting down" }
    when (/^re/)     { p "restarting" }
    default          { p "unknown: $cmd" }
}

See match for stryke-native pattern matching with destructuring.

# when

A case clause inside a given block. The expression is matched against the topic _ using smartmatch semantics: strings match exactly, regexes match against _, arrayrefs check membership, coderefs are called with _ as argument, and numbers compare numerically. When a when clause matches, its block executes and control exits the enclosing given (implicit break). Multiple when clauses are tried in order until one matches.

given ($val) {
    when (/^\d+$/)      { p "number" }
    when (["a","b","c"]) { p "early letter" }
    when (42)            { p "the answer" }
    default              { p "something else" }
}

In stryke, the match keyword provides more powerful pattern matching.

# default

The fallback clause in a given block, executed when no when clause matched. Every given should have a default to handle unexpected values, similar to else in an if chain or the wildcard _ arm in stryke match. If no default is present and nothing matches, execution simply continues after the given block. In stryke match, use _ => ... for the default arm instead.

given ($exit_code) {
    when (0) { p "success" }
    when (1) { p "general error" }
    when (2) { p "misuse" }
    default  { p "unknown exit code: $exit_code" }
}

# return

Return a value from a subroutine.

fn clamp($v, $lo, $hi) {
    return $lo if $v < $lo
    return $hi if $v > $hi
    $v
}

# 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 $a == $b is not($a == $b) rather than (!$a) == $b. 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)

# try

Structured exception handling that cleanly separates the happy path from error recovery. The try block runs the code; if it throws (via die), execution jumps to the catch block with the exception bound to the declared variable. An optional finally block runs unconditionally afterward — ideal for cleanup like closing filehandles or releasing locks. Unlike eval, try/catch is a first-class statement with proper scoping and no $@ pollution. In stryke, try integrates with all exception types including string messages, hashrefs, and objects.

try {
    my $data = fetch_json($url)
    p $data->{name}
} catch ($e) {
    warn "request failed: $e"
    return fallback()
} finally {
    log_info("fetch attempt complete")
}

Prefer try/catch over eval { } for new code — it reads better and avoids $@ clobbering races.

# catch

The error-handling clause that follows a try block. When the try block throws an exception, execution transfers to catch with the exception value bound to the declared variable (e.g. $e). The catch variable is lexically scoped to the catch block. You can inspect the exception — it may be a string, a hashref with structured error info, or an object with methods. Multiple error types can be differentiated with ref or match inside the catch body. If the catch block itself throws, the exception propagates upward (the finally block still runs first, if present).

try { die { code => 404, msg => "not found" } }
catch ($e) {
    if (ref $e eq 'HASH') {
        p "error $e->{code}: $e->{msg}"
    } else {
        p "caught: $e"
    }
}

# finally

A cleanup block that runs after try/catch regardless of whether an exception was thrown or not. This guarantees resource cleanup even if the try block throws or the catch block re-throws. The finally block cannot change the exception or the return value — it is strictly for side effects like closing filehandles, releasing locks, or logging. If finally itself throws, that exception replaces the original one (avoid throwing in finally). finally is optional — you can use try/catch without it.

my $fh
try {
    open $fh, '<', $path or die $!
    process(<$fh>)
} catch ($e) {
    log_error("failed: $e")
} finally {
    close $fh if $fh   # always cleanup
}

# eval

The classic Perl exception-catching mechanism. eval { BLOCK } executes the block in an exception-trapping context: if the block throws (via die), execution continues after the eval with the error stored in $@. eval "STRING" compiles and executes Perl code at runtime — powerful but dangerous (code injection risk). In stryke, prefer try/catch for exception handling as it avoids the $@ clobbering pitfalls and reads more clearly. eval remains useful for dynamic code evaluation and backward compatibility with Perl 5 idioms.

eval { die "oops" }
if ($@) { p "caught: $@" }

# Eval string — dynamic code execution
my $expr = "2 + 2"
my $result = eval $expr
p $result   # 4

Caveat: $@ can be clobbered by intervening evals or destructors — try/catch avoids this.

# die

Raise an exception, immediately unwinding the call stack until caught by try/catch or eval. The argument can be a string (most common), a reference (hashref for structured errors), or an object. If uncaught, the program terminates and the message is printed to STDERR. In stryke, die works identically to Perl 5 and integrates with try/catch, eval, and the $@ mechanism. Convention: end die messages with \n to suppress the automatic "at FILE line LINE" suffix, or omit it to get location info for debugging.

fn divide($a, $b) {
    die "division by zero\n" unless $b
    $a / $b
}

# Structured error
die { code => 400, msg => "bad request", field => "email" }

# With automatic location
die "something broke"   # prints: something broke at script.pl line 5.

# warn

Print a warning message to STDERR without terminating the program. Behaves like die but only emits the message instead of throwing an exception. If the message does not end with \n, Perl appends the current file and line number. Warnings can be intercepted with $SIG{__WARN__} or suppressed with no warnings. In stryke, warn is useful for non-fatal diagnostics; for structured logging, use log_warn instead.

warn "file not found: $path" unless -e $path
warn "deprecated: use fetch_json instead\n"  # no line number

# Intercept warnings
local $SIG{__WARN__} = fn ($msg) { log_warn($msg) }
warn "redirected to logger"

# croak

Die from the caller's perspective — the error message reports the file and line of the *caller*, not the function that called croak. This is the right choice for library/module functions where the error is the caller's fault (bad arguments, misuse). Without croak, the user sees an error pointing at library internals, which is unhelpful. In stryke, croak is available as a builtin without use Carp. For debugging deep call chains, use confess instead to get a full stack trace.

fn parse($s) {
    croak "parse: empty input" unless length $s
    croak "parse: not JSON" unless $s =~ /^[{\[]/
    json_decode($s)
}

# Error will point at the call site, not inside parse()
my $data = parse("")   # dies: "parse: empty input at caller.pl line 5"

# confess

Die with a full stack trace from the point of the error all the way up through every caller. This is invaluable for debugging deep call chains where die or croak only show one frame. Each frame includes the package, file, and line number. In stryke, confess is available as a builtin without use Carp. Use confess during development for maximum diagnostic info; switch to croak in production-facing libraries where the trace would confuse end users.

fn validate($data) {
    confess "missing required field 'name'" unless $data->{name}
}
fn process($input) { validate($input) }
fn main { process({}) }   # full trace: main -> process -> validate

The trace output shows: missing required field 'name' at script.pl line 2.\n\tmain::validate called at line 4\n\t....

# my

Declare a lexically scoped variable visible only within the enclosing block or file. my is the workhorse of Perl variable declarations — use it for scalars ($), arrays (@), and hashes (%). Variables declared with my are invisible outside their scope, which prevents accidental cross-scope mutation. In stryke, my variables participate in pipe chains and can be destructured in list context. Uninitialized my variables default to undef.

my $name = "world"
my @nums = 1:5
my %cfg = (debug => 1, verbose => 0)
p "hello $name"
@nums |> grep _ > 2 |> e p$1

Use `my` everywhere unless you specifically need `our` (package global), `local` (dynamic scope), or `state` (persistent).

# our

Declare a package-global variable that is accessible as a lexical alias in the current scope. Unlike my, our variables are visible across the entire package and can be accessed from other packages via their fully qualified name (e.g. $Counter::total). This is useful for package-level configuration, shared counters, or variables that need to survive across file boundaries. In stryke, our variables are not mutex-protected — use mysync instead for parallel-safe globals.

package Counter
our $total = 0
fn bump { $total++ }
package main
Counter::bump() for 1:5
p $Counter::total   # 5

Prefer my for local state; reach for our only when other packages need access.

# local

Temporarily override a global variable's value for the duration of the current dynamic scope. When the scope exits, the original value is automatically restored. This is essential for modifying Perl's special variables (like $/, $\, $,) without permanently altering global state. Unlike my which creates a new variable, local saves and restores an existing global. In stryke, local works with all special variables and respects the same restoration semantics during exception unwinding.

local $/ = undef       # slurp mode
open my $fh, '<', 'data.txt' or die $!
my $body = <$fh>       # reads entire file
close $fh
# $/ restored to "\n" when scope exits

Common patterns: local $/ = undef (slurp), local $, = "," (join print args), local %ENV (temporary env).

# state

Declare a persistent lexical variable that retains its value across calls to the enclosing subroutine. Unlike my, which reinitializes on each call, state initializes only once — the first time execution reaches the declaration — and preserves the value for all subsequent calls. This is perfect for counters, caches, and memoization without resorting to globals or closures over external variables. In stryke, state variables are per-thread when used inside ~> { } or fan blocks; they are not shared across workers.

fn counter {
    state $n = 0
    ++$n
}
p counter() for 1:5   # 1 2 3 4 5
fn memo($x) {
    state %cache
    $cache{$x} //= expensive($x)
}

Requires use feature 'state' in standard Perl, but is always available in stryke.

# package

Set the current package namespace for all subsequent declarations. Package names are conventionally CamelCase with :: separators (e.g. Math::Utils). All unqualified function and our variable names are installed into the current package. In stryke, packages work identically to standard Perl — they provide namespace isolation but are not classes by themselves (use struct or bless for OOP). Switching packages mid-file is allowed but discouraged; prefer one package per file.

package Math::Utils
fn factorial($n) { $n <= 1 ? 1 : $n * factorial($n - 1) }
fn fib($n) { $n < 2 ? $n : fib($n - 1) + fib($n - 2) }
package main
p Math::Utils::factorial(10)   # 3628800

# use

Load and import a module at compile time: use Module qw(func);.

use List::Util qw(sum max)
my @vals = 1:10
p sum(@vals)   # 55
p max(@vals)   # 10

# no

Unimport a module or pragma: no strict 'refs';.

no warnings 'experimental'
given ($x) { when (1) { p "one" } }

# require

Load a module at runtime: require Module;.

require JSON
my $data = JSON::decode_json($text)
p $data->{name}

# BEGIN

BEGIN { } — runs at compile time, before the rest of the program.

BEGIN { p "compiling..." }
p "running"
# output: compiling... then running

# END

END { } — runs after the program finishes (or on exit).

END { p "cleanup done" }
p "main work"
# output: main work then cleanup done

# cluster

cluster(["host1:N", "host2:M", ...]) — build an SSH-backed worker pool for distributing stryke workloads across multiple machines.

Each entry in the list is a hostname (or user@host) followed by a colon and the number of worker slots to allocate on that host. Under the hood, stryke opens persistent SSH multiplexed connections to each host, deploys lightweight stryke --remote-worker processes, and manages a work-stealing scheduler across the entire cluster. The cluster object is then passed to distributed primitives like pmap_on and pflat_map_on. Workers must have stryke installed and accessible on $PATH. If a host becomes unreachable mid-computation, its in-flight tasks are automatically re-queued to surviving hosts.

my $cl = cluster(["server1:8", "server2:4", "gpu-box:16"])
my @results = pmap_on $cl, { heavy_compute } @jobs

# Single-machine cluster for testing:
my $local = cluster(["localhost:4"])

# pmap_on

pmap_on $cluster, { BLOCK } @list — distributed parallel map that fans work across a cluster of remote machines.

Elements from @list are serialized, shipped to remote stryke --remote-worker processes over SSH, executed in parallel across every worker slot in the cluster, and the results are gathered back in input order. This is the distributed equivalent of pmap: same interface, same order guarantee, but the thread pool spans multiple hosts instead of local cores. Use this when a single machine's CPU count is the bottleneck. The block must be self-contained — it cannot close over local file handles or database connections, since it executes in a separate process on a remote host. Large closures are serialized once and cached on each worker for the lifetime of the cluster.

my $cl = cluster(["host1:8", "host2:8"])
my @hashes = pmap_on $cl, { sha256(slurp) } @file_paths
my @results = pmap_on $cl, { fetch("https://api.example.com/$_") } 1:10_000

# pflat_map_on

Distributed parallel flat-map over cluster.

# ssh

ssh($host, $command) — execute a shell command on a remote host via SSH and return its stdout as a string.

This is a simple synchronous wrapper around an SSH invocation. The command is run in the remote user's default shell, and stdout is captured and returned. If the remote command exits non-zero, stryke dies with the stderr output. For bulk remote work, prefer cluster + pmap_on which manages connection pooling and parallelism automatically. ssh is best for one-off administrative commands, health checks, or bootstrapping a remote environment before building a cluster.

my $uptime = ssh("server1", "uptime")
p ssh("deploy@prod", "cat /etc/hostname")
my $free = ssh("gpu-box", "nvidia-smi --query-gpu=memory.free --format=csv,noheader")

# datetime_utc

Return the current UTC date and time as an ISO 8601 string (e.g. 2026-04-15T12:30:00Z). This is the simplest way to get a portable, unambiguous timestamp for logging, file naming, or serialization. The returned string always ends with Z indicating UTC, so there is no timezone ambiguity.

my $now = datetime_utc()
p $now                          # 2026-04-15T12:30:00Z
af("audit.log", "$now: started\n")
my %event = (ts => datetime_utc(), action => "deploy")
wj("event.json", \%event)

# datetime_from_epoch

Convert a Unix epoch timestamp (seconds since 1970-01-01 00:00:00 UTC) into an ISO 8601 datetime string. This is useful when you have raw epoch values from time(), file modification times, or external APIs and need a human-readable representation. Fractional seconds are truncated.

my $ts = 1700000000
p datetime_from_epoch($ts)       # 2023-11-14T22:13:20Z
my $born = datetime_from_epoch(0)
p $born                          # 1970-01-01T00:00:00Z
my @epochs = (1e9, 1.5e9, 2e9)
@epochs |> e { p datetime_from_epoch }

# datetime_strftime

Format an epoch timestamp using a strftime-style format string, giving full control over the output representation. The first argument is the format pattern and the second is the epoch value. Supports all standard specifiers: %Y (4-digit year), %m (month), %d (day), %H (hour), %M (minute), %S (second), %A (weekday name), and more.

my $t = time()
p datetime_strftime("%Y-%m-%d", $t)        # 2026-04-15
p datetime_strftime("%H:%M:%S", $t)        # 14:23:07
p datetime_strftime("%A, %B %d", $t)       # Wednesday, April 15
my $log_ts = datetime_strftime("%Y%m%d_%H%M%S", $t)
to_file("backup_$log_ts.sql", $data)

# datetime_now_tz

Return the current date and time in a specified IANA timezone as a formatted string. Pass a timezone name like America/New_York, Europe/London, or Asia/Tokyo. This avoids manual UTC-offset arithmetic and handles daylight saving transitions correctly. Dies if the timezone name is not recognized.

p datetime_now_tz("America/New_York")    # 2026-04-15 08:30:00 EDT
p datetime_now_tz("Asia/Tokyo")           # 2026-04-15 21:30:00 JST
p datetime_now_tz("UTC")                  # same as datetime_utc
my @offices = ("US/Pacific", "Europe/Berlin", "Asia/Kolkata")
@offices |> e { p "_: " . datetime_now_tz }

# datetime_format_tz

Format an epoch timestamp in a specific IANA timezone, combining the capabilities of datetime_strftime and datetime_now_tz. This lets you render a historical or future timestamp as it would appear on the wall clock in any timezone. Handles DST transitions automatically.

my $epoch = 1700000000
p datetime_format_tz($epoch, "America/Chicago")
# 2023-11-14 16:13:20 CST
p datetime_format_tz($epoch, "Europe/London")
# 2023-11-14 22:13:20 GMT
p datetime_format_tz(time(), "Australia/Sydney")

# datetime_parse_local

Parse a local datetime string (without timezone info) into a Unix epoch timestamp, interpreting it in the system's local timezone. Accepts common formats like 2026-04-15 14:30:00 or 2026-04-15T14:30:00. Dies if the string cannot be parsed. This is the inverse of formatting with localtime.

my $epoch = datetime_parse_local("2026-04-15 14:30:00")
p $epoch                          # Unix timestamp
p datetime_from_epoch($epoch)     # back to ISO 8601
my $midnight = datetime_parse_local("2026-01-01 00:00:00")
p time() - $midnight              # seconds since New Year

# datetime_parse_rfc3339

Parse an RFC 3339 / ISO 8601 datetime string (with timezone offset or Z suffix) into a Unix epoch timestamp. This is the standard format used by JSON APIs, RSS feeds, and git timestamps. Accepts strings like 2026-04-15T14:30:00Z or 2026-04-15T14:30:00+05:30. Dies on malformed input.

my $epoch = datetime_parse_rfc3339("2026-04-15T12:00:00Z")
p $epoch
my $with_tz = datetime_parse_rfc3339("2026-04-15T08:00:00-04:00")
p $epoch == $with_tz              # 1 (same instant)
# parse API response timestamps
my $created = $response->{created_at}
my $age = time() - datetime_parse_rfc3339($created)
p "created ${age}s ago"

# datetime_add_seconds

Add (or subtract) a number of seconds to an ISO 8601 datetime string and return the resulting ISO 8601 string. This performs calendar-aware arithmetic, correctly crossing day, month, and year boundaries. Pass a negative number to subtract time. Useful for computing deadlines, expiration times, or time windows.

my $now = datetime_utc()
my $later = datetime_add_seconds($now, 3600)     # +1 hour
p $later
my $yesterday = datetime_add_seconds($now, -86400) # -1 day
p $yesterday
my $deadline = datetime_add_seconds($now, 7 * 86400) # +1 week
p "due by $deadline"

# elapsed

Return the number of seconds elapsed since the stryke process started, using a monotonic clock that is immune to system clock adjustments. The short alias el keeps benchmarking one-liners terse. Returns a floating-point value with sub-millisecond precision. Useful for timing operations, profiling hot loops, or adding relative timestamps to log output.

my $t0 = el()
my @sorted = sort @big_array
my $dur = el() - $t0
p "sort took ${dur}s"
# progress logging
1:100 |> e { do_work
    log_info("step $_ at " . el() . "s") }

# time

Return the current Unix epoch as an integer — the number of seconds since 1970-01-01 00:00:00 UTC. This is the standard wall-clock timestamp used for file times, database records, and interop with external systems. For monotonic timing of code sections, prefer elapsed/el instead since time can jump if the system clock is adjusted.

my $start = time()
sleep(2)
p time() - $start   # ~2
my $ts = time()
wj("stamp.json", { created => $ts })
p datetime_from_epoch($ts)  # human-readable form

# times

Return the accumulated CPU times for the process as a four-element list: ($user, $system, $child_user, $child_system). User time is CPU spent executing your code; system time is CPU spent in kernel calls on your behalf. Child times cover subprocesses. Values are in seconds (floating point). Useful for profiling whether a script is CPU-bound or I/O-bound.

my ($u, $s, $cu, $cs) = times()
p "user=${u}s sys=${s}s"
# after heavy computation
my ($u2, $s2) = times()
p "used " . ($u2 - $u) . "s of CPU"
p "total CPU: " . ($u2 + $s2) . "s"

# localtime

Convert a Unix epoch timestamp to a nine-element list of broken-down local time components: ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday, $isdst). Follows the Perl convention where $mon is 0-based (January=0) and $year is years since 1900. When called without arguments, uses the current time. Use gmtime for the UTC equivalent.

my @t = localtime(time())
p "$t[2]:$t[1]:$t[0]"                 # HH:MM:SS
my $year = $t[5] + 1900
my $mon  = $t[4] + 1
p "$year-$mon-$t[3]"                   # YYYY-M-D
my @days = qw(Sun Mon Tue Wed Thu Fri Sat)
p $days[$t[6]]                          # day of week

# gmtime

Convert a Unix epoch timestamp to a nine-element list of broken-down UTC time components, identical in structure to localtime but always in the UTC timezone. The fields are ($sec, $min, $hour, $mday, $mon, $year, $wday, $yday, $isdst) where $isdst is always 0. When called without arguments, uses the current time.

my @utc = gmtime(time())
my $year = $utc[5] + 1900
my $mon  = $utc[4] + 1
p sprintf("%04d-%02d-%02dT%02d:%02d:%02dZ",
    $year, $mon, @utc[3,2,1,0])
# compare local vs UTC
my @loc = localtime(time())
p "UTC hour=$utc[2] local hour=$loc[2]"

# sleep

Pause execution for the specified number of seconds. Accepts both integer and fractional values for sub-second sleeps (e.g. sleep 0.1 for 100ms). The process yields the CPU during the sleep, so it is safe to use in polling loops without burning cycles. Returns the unslept time (always 0 unless interrupted by a signal).

p "waiting..."
sleep(2)
p "done"
# polling loop
while (!-e "done.flag") {
    sleep(0.5)
}
# rate limiting
my @urls = @targets
@urls |> e { fetch
    sleep(0.1) }

# alarm

Schedule a SIGALRM signal to be delivered to the process after the specified number of seconds. Calling alarm(0) cancels any pending alarm. Only one alarm can be active at a time — setting a new alarm replaces the previous one. Returns the number of seconds remaining on the previous alarm (or 0 if none was set). Combine with eval and $SIG{ALRM} to implement timeouts around potentially hanging operations.

eval {
    local $SIG{ALRM} = fn { die "timeout\n" }
    alarm(5)           # 5 second deadline
    my $data = slow_network_call()
    alarm(0)           # cancel on success
}
if ($@ =~ /timeout/) {
    log_error("operation timed out")
}

# abs

Return the absolute value of a number, stripping any negative sign. Returns the argument unchanged if it is already non-negative. Works on both integers and floating-point numbers.

p abs(-42)       # 42
p abs(3.14)      # 3.14
my $diff = abs($a - $b)
p "distance: $diff"
1:5 |> map { _ - 3 } |> map abs |> e p  # 2 1 0 1 2

# int

Truncate a floating-point number toward zero, discarding the fractional part. This is not rounding — int(1.9) is 1 and int(-1.9) is -1. Use sprintf("%.0f", $n) or POSIX::round for proper rounding. Commonly paired with rand to generate random integers.

p int(3.7)       # 3
p int(-3.7)      # -3
p int(rand(6)) + 1  # dice roll 1:6
1:10 |> map { _ / 3 } |> map int |> e p

# sqrt

Return the square root of a non-negative number. Dies if the argument is negative — use abs first or check the sign. For the inverse operation, use squared/sq or the ** operator.

p sqrt(144)         # 12
p sqrt(2)           # 1.41421356...
my $hyp = sqrt($a**2 + $b**2)  # Pythagorean theorem
1:5 |> map sqrt |> e { p sprintf("%.3f", _) }

# squared

Return the square of a number (N * N). This is a stryke convenience function — clearer than writing $n ** 2 or $n * $n in pipelines. The aliases sq and square are interchangeable.

p squared(5)        # 25
p sq(12)            # 144
1:5 |> map sq |> e p    # 1 4 9 16 25
my $hyp = sqrt(sq($a) + sq($b))  # Pythagorean theorem

# cubed

Return the cube of a number (N * N * N). This is a stryke convenience function for the common $n ** 3 operation, useful in math-heavy pipelines. The aliases cb and cube are interchangeable.

p cubed(3)          # 27
p cb(10)            # 1000
1:4 |> map cb |> e p  # 1 8 27 64
my $vol = cb($side)             # volume of a cube

# expt

Raise a base to an arbitrary exponent and return the result. This is the function form of the ** operator. Accepts integer and floating-point exponents, including negative values for reciprocals and fractional values for roots.

p expt(2, 10)       # 1024
p expt(27, 1/3)     # 3.0 (cube root)
p expt(10, -2)      # 0.01
1:8 |> map { expt(2, _) } |> e p  # 2 4 8 16 32 64 128 256

# exp

Return Euler's number *e* raised to the given power. exp(0) is 1, exp(1) is approximately 2.71828. This is the inverse of log. Useful for exponential growth/decay calculations, probability distributions, and converting between logarithmic and linear scales.

p exp(1)            # 2.71828182845905
p exp(0)            # 1
my $growth = $initial * exp($rate * $time)
1:5 |> map exp |> e { p sprintf("%.4f", _) }

# log

Return the natural (base-*e*) logarithm of a positive number. Dies if the argument is zero or negative. For base-10 logarithms, divide by log(10). For base-2, divide by log(2). This is the inverse of exp.

p log(exp(1))       # 1.0
p log(100) / log(10)  # 2.0 (log base 10)
my $bits = log($n) / log(2)  # log base 2
1:5 |> map log |> e { p sprintf("%.3f", _) }

# sin

Return the sine of an angle given in radians. The result ranges from -1 to 1. For degrees, convert first: sin($deg * 3.14159265 / 180). Use atan2 to go in the reverse direction.

p sin(0)               # 0
p sin(3.14159265 / 2)  # 1.0
my @wave = map { sin(_ * 0.1) } 0:62
@wave |> e { p sprintf("%6.3f", _) }

# cos

Return the cosine of an angle given in radians. The result ranges from -1 to 1. cos(0) is 1. Like sin, convert degrees to radians before calling.

p cos(0)                 # 1
p cos(3.14159265)        # -1.0
my $x = $radius * cos($theta)
my $y = $radius * sin($theta)
p "($x, $y)"

# atan2

Return the arctangent of Y/X in radians, using the signs of both arguments to determine the correct quadrant. The result ranges from -pi to pi. This is the standard way to compute angles from Cartesian coordinates and is more robust than atan(Y/X) because it handles X=0 correctly.

my $pi = atan2(0, -1)       # 3.14159265...
p atan2(1, 1)               # 0.785... (pi/4)
my $angle = atan2($dy, $dx)
p sprintf("%.1f degrees", $angle * 180 / $pi)

# rand

Return a pseudo-random floating-point number in the range [0, N). If N is omitted it defaults to 1. The result is never exactly equal to N. For integer results, combine with int. Seed the generator with srand for reproducible sequences.

p rand()                # e.g. 0.7342...
p int(rand(100))        # random int 0:99
my @deck = 1:52
my @shuffled = sort { rand() <=> rand() } @deck  # poor shuffle
my $coin = rand() < 0.5 ? "heads" : "tails"
p $coin

# srand

Seed the pseudo-random number generator used by rand. Calling srand with a specific value produces a reproducible sequence, which is useful for testing. Without arguments, Perl seeds from a platform-specific entropy source. You rarely need to call this explicitly — Perl auto-seeds on first use of rand.

srand(42)                   # reproducible sequence
p int(rand(100))            # always the same value
srand(42)
p int(rand(100))            # same value again
srand()                     # re-seed from entropy

# basename

Extract the filename component from a path, stripping all leading directory segments. The short alias bn keeps one-liner pipelines terse. If an optional suffix argument is provided, that suffix is also stripped from the result, which is handy for removing extensions.

p basename("/usr/local/bin/stryke")        # stryke
p bn("/tmp/data.csv", ".csv")           # data
"/etc/nginx/nginx.conf" |> bn |> p      # nginx.conf

# dirname

Return the directory portion of a path, stripping the final filename component. The short alias dn mirrors bn. This is a pure string operation — it does not touch the filesystem, so it works on paths that do not exist yet. Useful for deriving output directories from input file paths.

p dirname("/usr/local/bin/stryke")          # /usr/local/bin
p dn("/tmp/data.csv")                   # /tmp
my $dir = dn($0)                        # directory of current script

# fileparse

Split a path into its three logical components: the filename, the directory prefix, and a suffix that matches one of the supplied patterns. This mirrors Perl's File::Basename::fileparse and is the most flexible path decomposition available. When no suffix patterns are given the suffix is empty.

my ($name, $dir, $sfx) = fileparse("/home/user/report.txt", qr/\.txt/)
p "$dir | $name | $sfx"  # /home/user/ | report | .txt
my ($n, $d) = fileparse("./lib/Foo/Bar.pm")
p "$d$n"                 # ./lib/Foo/Bar.pm

# realpath

Resolve a path to its absolute canonical form by following all symbolic links and eliminating . and .. segments. Unlike canonpath, this hits the filesystem and will die if any component does not exist. The short alias rp is convenient in pipelines. Use this when you need a guaranteed unique path for deduplication or comparison.

p realpath(".")                      # /home/user/project
p rp("../sibling")                   # /home/user/sibling
my $canon = rp($0)                  # absolute path of current script
"." |> rp |> p

# canonpath

Clean up a file path by collapsing redundant separators, resolving . and .. segments, and normalizing trailing slashes — all without touching the filesystem. Unlike realpath, this is a purely lexical operation so it works on paths that do not exist. Use it to normalize user-supplied paths before comparison or storage.

p canonpath("/usr/./local/../local/bin/")   # /usr/local/bin
p canonpath("a/b/../c")                     # a/c
my $clean = canonpath($ENV{HOME} . "/./docs/../docs")
p $clean

# getcwd

Return the current working directory as an absolute path string. This calls the underlying OS getcwd function, so it always reflects the real directory even if the process changed directories via chdir. The alias pwd matches the familiar shell command. Often used to save and restore directory context around chdir calls.

my $orig = pwd()
chdir("/tmp")
p pwd()      # /tmp
chdir($orig)
p getcwd()   # back to original

# which

Search the PATH environment variable for the first executable matching the given command name and return its absolute path, or undef if not found. This is the programmatic equivalent of the shell which command. Useful for checking tool availability before calling system or exec.

my $gcc = which("gcc") // die "gcc not found"
p $gcc                       # /usr/bin/gcc
if (which("rg")) {
    system("rg pattern file")
} else {
    system("grep pattern file")
}

# glob

Expand a shell-style glob pattern against the filesystem and return a list of matching paths. Supports *, ?, [abc], {a,b} patterns, and ** for recursive matching. This actually reads the filesystem, unlike glob_match which is a pure string test.

my @scripts = glob("*.pl")
@scripts |> e p
my @all_rs = glob("src/**/*.rs")
p scalar @all_rs              # count of Rust files
my @cfg = glob("/etc/{nginx,apache2}/*.conf")

# glob_match

Test whether a filename or path matches a shell-style glob pattern. Returns true (1) on match, false (empty string) otherwise. Supports *, ?, [abc], and {a,b} patterns. This is a pure string match — it does not read the filesystem, so it works for filtering lists of paths you already have.

p glob_match("*.pl", "script.pl")        # 1
p glob_match("*.pl", "script.py")        # (empty)
my @perl = grep { glob_match("*.{pl,pm}", _) } @files
@perl |> e p

# copy

Copy a file from a source path to a destination path. The destination can be a file path or a directory (in which case the source filename is preserved). Dies on failure. This is the programmatic equivalent of cp and avoids shelling out. Metadata such as permissions is preserved where possible.

copy("src/config.yaml", "/tmp/config.yaml")
copy("report.pdf", "/backup/")
my $tmp = tf()
copy($0, $tmp)  # back up the current script
p slurp($tmp)

# move

Move or rename a file from source to destination. If the source and destination are on the same filesystem this is an atomic rename; otherwise it falls back to copy-then-delete. Dies on failure. The short alias mv mirrors the shell command.

move("draft.txt", "final.txt")         # rename in place
mv("output.csv", "/archive/output.csv") # move across dirs
my $tmp = tf()
spurt($tmp, "data")
mv($tmp, "data.txt")

# rename

Rename a file or directory from an old name to a new name. This is an atomic operation on the same filesystem. If the destination already exists it is silently replaced. Dies on failure. Unlike move/mv, this does not fall back to copy-then-delete across filesystems.

rename("draft.md", "final.md")
rename("output", "output_v2")          # works on dirs too
my $bak = "config.yaml.bak"
rename("config.yaml", $bak)
spurt("config.yaml", $new_config)

# unlink

Delete one or more files from the filesystem. Returns the number of files successfully removed. Does not remove directories — use rmdir for those. Dies on permission errors. Accepts a list of paths, making it convenient for batch cleanup.

unlink("temp.log")
my $n = unlink("a.tmp", "b.tmp", "c.tmp")
p "removed $n files"
my @old = glob("*.bak")
unlink(@old)

# mkdir

Create a directory at the given path. An optional second argument specifies the permission mode as an octal number (default 0777, modified by the current umask). Dies if the directory cannot be created. Only creates one level — use make_path or shell out for recursive creation.

mkdir("output")
mkdir("/tmp/secure", 0700)
my $dir = tdr() . "/sub"
mkdir($dir)
p -d $dir    # 1

# rmdir

Remove an empty directory. Dies if the directory does not exist, is not empty, or cannot be removed due to permissions. This only removes a single directory — it will not recursively delete contents. Remove files with unlink first, then call rmdir.

mkdir("scratch")
rmdir("scratch")
p -d "scratch"   # (empty, dir is gone)
unlink("tmp/file.txt")
rmdir("tmp")

# chmod

Change the permission bits of one or more files. The mode is specified as an octal number. Returns the number of files successfully changed. Does not follow symlinks on some platforms. Use stat to read the current mode before modifying.

chmod(0755, "script.pl")
chmod(0644, "config.yaml", "data.json")
my $n = chmod(0600, glob("*.key"))
p "secured $n key files"

# chown

Change the owner and group of one or more files, specified as numeric UID and GID. Pass -1 for either to leave it unchanged. Returns the number of files successfully changed. Typically requires root privileges.

chown(1000, 1000, "app.log")
chown(-1, 100, "shared.txt")     # change group only
my $uid = (getpwnam("deploy"))[2]
chown($uid, -1, "release.tar")

# chdir

Change the current working directory of the process. Dies if the directory does not exist or is not accessible. This affects all subsequent relative path operations. Pair with getcwd/pwd to save and restore the original directory.

my $orig = pwd()
chdir("/tmp")
spurt("scratch.txt", "hello")
chdir($orig)                  # return to original

# stat

Return a 13-element list of file status information for a path or filehandle: ($dev, $ino, $mode, $nlink, $uid, $gid, $rdev, $size, $atime, $mtime, $ctime, $blksize, $blocks). This calls the POSIX stat system call. Use it to check file size, modification time, permissions, and other metadata without reading the file.

my @st = stat("data.bin")
p "size: $st[7] bytes"
p "modified: " . datetime_from_epoch($st[9])
my ($mode) = (stat($0))[2]
p sprintf("perms: %04o", $mode & 07777)

# link

Create a hard link — a new directory entry pointing to the same underlying inode as the original file. Both names are indistinguishable and share the same data; removing one does not affect the other. Hard links cannot cross filesystem boundaries and typically cannot link directories.

link("data.csv", "data_backup.csv")
my @st1 = stat("data.csv")
my @st2 = stat("data_backup.csv")
p $st1[1] == $st2[1]   # 1 — same inode

# symlink

Create a symbolic (soft) link that points to a target path. Unlike hard links, symlinks can cross filesystems and can point to directories. The link stores the target as a string, so it can dangle if the target is later removed. Use readlink to inspect where a symlink points.

symlink("/usr/local/bin/stryke", "pe_link")
p readlink("pe_link")       # /usr/local/bin/stryke
p -l "pe_link"              # 1 (is a symlink)
symlink("../lib", "lib_link")  # relative target

# readlink

Return the target path that a symbolic link points to, without following the link further. Returns undef if the path is not a symlink. This is useful for inspecting symlink chains, verifying link targets, or resolving one level of indirection at a time.

symlink("real.conf", "link.conf")
my $target = readlink("link.conf")
p $target                    # real.conf
if (defined readlink($path)) {
    p "$path is a symlink"
}

# utime

Set the access time and modification time of one or more files. Times are specified as epoch seconds. Pass undef for either time to set it to the current time. Returns the number of files successfully updated. Useful for cache invalidation, build systems, or preserving timestamps after transformations.

utime(time(), time(), "output.txt")     # touch to now
my $epoch = 1700000000
utime($epoch, $epoch, @files)           # backdate files
utime(undef, undef, "marker.flag")      # equivalent of touch

# umask

Get or set the file creation mask, which controls the default permissions for newly created files and directories. When called with an argument, sets the new mask and returns the previous one. When called without arguments, returns the current mask. The mask is subtracted from the requested permissions in mkdir, open, etc.

my $old = umask(0077)         # restrict: owner-only
mkdir("private")               # created with 0700
umask($old)                    # restore previous mask
p sprintf("%04o", umask())     # print current mask

# uname

Return system identification as a five-element list: ($sysname, $nodename, $release, $version, $machine). This calls the POSIX uname system call and is useful for platform-specific logic, logging system info, or generating diagnostic reports without shelling out.

my ($sys, $node, $rel, $ver, $arch) = uname()
p "$sys $rel ($arch)"           # Linux 6.1.0 (x86_64)
if ($sys eq "Darwin") {
    p "running on macOS"
}
log_info("host: $node, kernel: $rel")

# gethostname

Return the hostname of the current machine as a string. This calls the POSIX gethostname system call. The short alias hn is useful in log prefixes, temp-file naming, or distributed-system identifiers where you need to tag output by machine.

p gethostname()                          # myhost.local
my $log_prefix = hn() . ":" . $$        # myhost.local:12345
log_info("running on " . hn())

# opendir

Open a directory handle for reading its entries. Returns a directory handle that can be passed to readdir, seekdir, telldir, rewinddir, and closedir. Dies if the directory does not exist or cannot be opened. For most use cases glob or readdir with a path is simpler.

opendir(my $dh, "/tmp") or die "cannot open: $!"
my @entries = readdir($dh)
closedir($dh)
@entries |> grep { _ !~ /^\./ } |> e p  # skip dotfiles

# readdir

Read entries from a directory handle opened with opendir. In list context, returns all remaining entries. In scalar context, returns the next single entry or undef when exhausted. Entries include . and .. so you typically filter them out.

opendir(my $dh, ".") or die $!
while (my $entry = readdir($dh)) {
    next if $entry =~ /^\./
    p $entry
}
closedir($dh)

# closedir

Close a directory handle previously opened with opendir, releasing the underlying OS resource. While directory handles are closed automatically when they go out of scope, explicit closedir is good practice in long-running programs or loops that open many directories.

opendir(my $dh, "/var/log") or die $!
my @logs = readdir($dh)
closedir($dh)
@logs |> grep { /\.log$/ } |> e p

# seekdir

Set the current position in a directory handle to a location previously obtained from telldir. This allows you to revisit directory entries without closing and reopening the handle. Rarely needed in practice, but useful for multi-pass directory scanning.

opendir(my $dh, ".") or die $!
my $pos = telldir($dh)
my @first_pass = readdir($dh)
seekdir($dh, $pos)              # rewind to saved position
my @second_pass = readdir($dh)
closedir($dh)

# telldir

Return the current read position within a directory handle as an opaque integer. The returned value can be passed to seekdir to return to that position later. This is the directory-handle equivalent of tell for file handles.

opendir(my $dh, "/tmp") or die $!
readdir($dh)                  # skip .
readdir($dh)                  # skip ..
my $pos = telldir($dh)        # save position after . and ..
my @real = readdir($dh)
seekdir($dh, $pos)            # go back

# rewinddir

Reset a directory handle back to the beginning so that the next readdir returns the first entry again. This is equivalent to closing and reopening the directory but more efficient. Useful when you need to iterate a directory multiple times.

opendir(my $dh, "src") or die $!
my $count = scalar readdir($dh)
rewinddir($dh)
my @entries = readdir($dh)
closedir($dh)
p "$count entries"

# du

du (alias dir_size) — compute the total size of a directory tree in bytes, recursively walking all files.

my $bytes = du("/usr/local")
p "$bytes bytes"

# du_tree

du_tree (alias dir_sizes) — return directory sizes as an array of hashrefs {path, size}, sorted descending by size. Each entry is an immediate child directory.

my @dirs = du_tree("/usr/local")
for (@dirs) { p "_->{path}: _->{size}" }

# system

Execute a command in a subshell and wait for it to complete, returning the exit status. A return value of 0 means success; non-zero indicates failure. The exit status is encoded as $? >> 8 for the actual exit code. Use backticks or capture if you need the command's output.

my $rc = system("make", "test")
p "exit code: " . ($rc >> 8)
system("cp data.csv /backup/") == 0 or die "copy failed"
if (system("which rg >/dev/null 2>&1") == 0) {
    p "ripgrep is installed"
}

# exec

Replace the current process image entirely with a new command. This never returns on success — the new program takes over. If exec fails (command not found, permission denied) it returns false and execution continues. Use system instead if you want to run a command and keep the current process alive.

exec("ls", "-la", "/tmp") or die "exec failed: $!"
# code here only runs if exec fails

# common fork+exec pattern
if (fork() == 0) {
    exec("worker", "--daemon")
}

# exe

exe (alias executables) — list executable file names in a directory (default: current directory). Returns a sorted array of filenames that have the executable bit set. On non-Unix platforms, matches files with .exe, .bat, or .cmd extensions.

p for exe                    # list executables in $PWD
p for exe("/usr/local/bin")  # list executables in a specific dir
exe |> grep /^s/ |> e p     # executables starting with 's'

# fork

Fork the current process, creating a child that is an exact copy of the parent. Returns the child's PID to the parent process and 0 to the child, allowing each side to branch. Returns undef on failure. Always pair with wait/waitpid to reap the child and avoid zombies.

my $pid = fork()
if ($pid == 0) {
    p "child $$"
    exit(0)
}
p "parent $$, child is $pid"
waitpid($pid, 0)

# wait

Wait for any child process to terminate and return its PID. The exit status is stored in $?. If there are no child processes, returns -1. This is the simplest reaping function — use waitpid when you need to wait for a specific child or use non-blocking flags.

for (1:3) {
    fork() or do { sleep(1)
    exit(0) }
}
while ((my $pid = wait()) != -1) {
    p "child $pid exited with " . ($? >> 8)
}

# waitpid

Wait for a specific child process identified by PID to change state. The flags argument controls behavior — use 0 for blocking wait, or WNOHANG for non-blocking (returns 0 if child is still running). Returns the PID on success, -1 if the child does not exist. Exit status is in $?.

my $pid = fork() // die "fork: $!"
if ($pid == 0) { sleep(2)
    exit(42) }
waitpid($pid, 0)
p "child exited: " . ($? >> 8)   # 42

# non-blocking poll
while (waitpid($pid, WNOHANG) == 0) {
    p "still running..."
    sleep(1)
}

# kill

Send a signal to one or more processes by PID. The signal can be specified as a number (9) or a name ("TERM"). Sending signal 0 tests whether the process exists without actually sending anything. Returns the number of processes successfully signaled.

kill("TERM", $child_pid)
kill(9, @worker_pids)                # SIGKILL
if (kill(0, $pid)) {
    p "process $pid is alive"
}
my $n = kill("HUP", @daemons)
p "signaled $n processes"

# exit

Terminate the program immediately with the given exit status code. An exit code of 0 conventionally means success; any non-zero value indicates an error. END blocks and object destructors are still run. Use POSIX::_exit to skip cleanup entirely.

exit(0)                 # success
exit(1) if $error       # failure

# conditional exit in a pipeline
my $ok = system("make test")
exit($ok >> 8) if $ok

# getlogin

Return the login name of the user who owns the current terminal session. This reads from the system's utmp/utmpx database and may return undef for processes without a controlling terminal (cron jobs, daemons). For a more reliable alternative, use getpwuid($<) which looks up the effective UID.

my $user = getlogin() // (getpwuid($<))[0]
p "running as $user"
log_info("session started by " . getlogin())

# getpwnam

Look up user account information by username string. Returns the same 9-element list as getpwuid: ($name, $passwd, $uid, $gid, $quota, $comment, $gcos, $dir, $shell). Returns empty list if the user does not exist. Useful for resolving a username to a UID before calling chown.

my @info = getpwnam("deploy")
p "uid=$info[2] home=$info[7]"
my $uid = (getpwnam("www-data"))[2]
chown($uid, -1, "public/index.html")

# getpwuid

Look up user account information by numeric UID. Returns ($name, $passwd, $uid, $gid, $quota, $comment, $gcos, $dir, $shell) on success, or empty list if the UID does not exist. This is the reliable way to map a UID to a username and home directory.

my ($name, undef, undef, undef, undef, undef, undef, $home) = getpwuid($<)
p "user: $name, home: $home"
my $root_shell = (getpwuid(0))[8]
p $root_shell   # /bin/bash or /bin/zsh

# getpwent

Read the next entry from the system password database, iterating through all user accounts. Returns ($name, $passwd, $uid, $gid, $quota, $comment, $gcos, $dir, $shell) for each user, or empty list when exhausted. Call setpwent to rewind and endpwent to close.

while (my @pw = getpwent()) {
    p "$pw[0]: uid=$pw[2] home=$pw[7]"
}
endpwent()

# getgrgid

Look up group information by numeric GID. Returns ($name, $passwd, $gid, $members) where members is a space-separated string of usernames belonging to the group. Returns empty list if the GID does not exist.

my ($name, undef, undef, $members) = getgrgid(0)
p "group $name: $members"
my $gname = (getgrgid((stat("file.txt"))[5]))[0]
p "file group: $gname"

# getgrnam

Look up group information by group name string. Returns ($name, $passwd, $gid, $members). Useful for resolving a group name to a GID before calling chown, or for checking group membership.

my ($name, undef, $gid, $members) = getgrnam("staff")
p "gid=$gid members=$members"
chown(-1, $gid, "shared_dir")
if ((getgrnam("admin"))[3] =~ /\b$user\b/) {
    p "$user is an admin"
}

# getgrent

Read the next entry from the system group database, iterating through all groups. Returns ($name, $passwd, $gid, $members) for each group, or empty list when exhausted. The members field is a space-separated string of usernames. Call endgrent when done.

while (my @gr = getgrent()) {
    p "$gr[0]: gid=$gr[2] members=$gr[3]"
}
endgrent()

# getppid

Return the process ID of the parent process. This is useful for detecting whether the process has been orphaned (parent PID becomes 1 on Unix when the original parent exits), or for logging the process hierarchy. Always returns a valid PID.

p "my pid: $$, parent: " . getppid()
if (getppid() == 1) {
    log_warn("parent process has exited, we are orphaned")
}

# getpgrp

Return the process group ID of the current process (or of the specified PID). Processes in the same group receive signals together — for example, Ctrl-C sends SIGINT to the entire foreground process group. Use setpgrp to move a process into a different group.

p "process group: " . getpgrp()
my $pg = getpgrp($$)
p $pg == $$ ? "group leader" : "group member"

# setpgrp

Set the process group ID of a process. Call setpgrp(0, 0) to make the current process a new group leader, which is useful for daemonization or isolating a subprocess from the terminal's signal group. Takes (PID, PGID) — use 0 for the current process.

setpgrp(0, 0)   # become process group leader
if (fork() == 0) {
    setpgrp(0, 0)  # child gets its own group
    exec("worker")
}

# getpriority

Get the scheduling priority (nice value) of a process, process group, or user. The which argument selects the target type: PRIO_PROCESS, PRIO_PGRP, or PRIO_USER. Lower values mean higher priority. The default nice value is 0; range is typically -20 to 19.

my $nice = getpriority(0, $$)    # PRIO_PROCESS, current PID
p "nice value: $nice"
my $user_prio = getpriority(2, $<)  # PRIO_USER, current user
p "user priority: $user_prio"

# setpriority

Set the scheduling priority (nice value) of a process, process group, or user. Lowering the nice value (higher priority) typically requires root privileges. Raising it (lower priority) is always allowed. Use this to deprioritize background batch work or boost latency-sensitive tasks.

setpriority(0, $$, 10)   # lower priority for batch work
if (fork() == 0) {
    setpriority(0, 0, 19)  # lowest priority for child
    exec("batch-job")
}

# syscall

Invoke a raw system call by its numeric identifier, passing arguments directly to the kernel. This is an escape hatch for system calls that have no Perl wrapper. The call number is platform-specific and the arguments must be correctly typed (integers or string buffers). Use with caution — incorrect arguments can crash the process.

# SYS_getpid on Linux x86_64 is 39
my $pid = syscall(39)
p $pid                     # same as $$
# SYS_sync on Linux is 162
syscall(162)               # flush filesystem caches

# process_list

process_list (aliases ps, procs) — list running processes as an array of hashrefs with {pid, name, uid} keys.

my @procs = ps()
for (@procs) { p "_->{pid} _->{name}" }

# pack

Convert a list of values into a binary string according to a template. Each template character specifies how one value is encoded: N for 32-bit big-endian unsigned, n for 16-bit, a for raw bytes, Z for null-terminated string, etc. This is essential for constructing binary protocols, file formats, and sockaddr structures.

my $bin = pack("NnA4", 0xDEADBEEF, 8080, "test")
p length($bin)                # 10 bytes
my $header = pack("A8 N N", "MAGIC01\0", 1, 42)
spurt("data.bin", $header)

# unpack

Decode a binary string into a list of values according to a template, performing the inverse of pack. The template characters must match how the data was packed. Use this for parsing binary file formats, network protocol headers, or any structured binary data.

my ($magic, $version, $count) = unpack("A8 N N", $header)
p "v$version, $count records"
my ($port, $addr) = unpack("n a4", $sockaddr)
p inet_ntoa($addr) . ":$port"

# vec

Treat a string as a bit vector and get or set individual elements at a specified bit width. The first argument is the string, the second is the element offset, and the third is the bit width (1, 2, 4, 8, 16, or 32). As an lvalue, vec modifies the string in place. Useful for compact boolean arrays and bitmap manipulation.

my $bits = ""
vec($bits, 0, 1) = 1   # set bit 0
vec($bits, 7, 1) = 1   # set bit 7
p vec($bits, 0, 1)     # 1
p vec($bits, 3, 1)     # 0
p unpack("B8", $bits)  # 10000001

# log_info

Log a message at INFO level to stderr with a timestamp prefix. INFO is the default visible level and is appropriate for normal operational messages — startup notices, progress milestones, summary statistics. Messages are suppressed if the current log level is set higher than INFO.

log_info("server started on port $port")
my @rows = rl("data.csv")
log_info("loaded " . scalar(@rows) . " rows")
1:5 |> e { log_info("processing item _") }

# log_warn

Log a message at WARN level to stderr. Warnings indicate unexpected but recoverable situations — missing optional config, deprecated usage, slow operations. WARN messages appear at the default log level and are visually distinct from INFO in structured log output.

log_warn("config file not found, using defaults")
log_warn("query took ${elapsed}s, exceeds threshold")
unless (-e $path) {
    log_warn("$path missing, skipping")
}

# log_error

Log a message at ERROR level to stderr. Use this for failures that prevent an operation from completing but do not necessarily terminate the program — failed network requests, invalid input, permission errors. ERROR is always visible regardless of log level.

log_error("failed to connect to $host: $!")
eval { rj("bad.json") }
log_error("parse failed: $@") if $@
log_error("missing required field 'name'")

# log_debug

Log a message at DEBUG level to stderr. Debug messages are hidden by default and only appear when the log level is lowered to DEBUG or TRACE via log_level. Use for detailed internal state that helps during development — variable dumps, branch decisions, intermediate values.

log_level("debug")
log_debug("cache key: $key")
my $result = compute($x)
log_debug("compute($x) => $result")
@items |> e { log_debug("item: $_") }

# log_trace

Log a message at TRACE level to stderr. This is the most verbose level, producing very fine-grained output — loop iterations, function entry/exit, raw payloads. Only visible when log_level("trace") is set. Use sparingly in production code; primarily for deep debugging sessions.

log_level("trace")
fn process($x) {
    log_trace("entering process($x)")
    my $r = $x * 2
    log_trace("leaving process => $r")
    $r
}
1:3 |> map process |> e p

# log_json

Emit a structured JSON log line to stderr containing the message plus any additional key-value metadata. This is designed for machine-parseable logging pipelines — centralized log collectors, JSON-based monitoring, or jq-friendly output. Each call emits exactly one JSON object per line.

log_json("request", method => "GET", path => "/api")
log_json("metric", name => "latency_ms", value => 42)
log_json("error", msg => $@, file => $0)$1

Note: all values are serialized as JSON strings.

# log_level

Get or set the current minimum log level. When called with no arguments, returns the current level as a string. When called with a level name, sets it for all subsequent log calls. Valid levels from most to least verbose: trace, debug, info, warn, error. The default level is info.

p log_level()         # info
log_level("debug")    # enable debug output
log_debug("now visible")
log_level("error")    # suppress everything below error
log_info("hidden")    # not printed

# scatter_svg

scatter_svg (alias scatter_plot) — generate an SVG scatter plot. Args: xs, ys [, title]. Dark theme, auto-scaled axes.

scatter_svg([1,2,3,4], [1,4,9,16], "Squares") |> to_file("scatter.svg")

# line_svg

line_svg (alias line_plot) — generate an SVG line plot. Args: xs, ys [, title].

my @x = map { _ * 0.1 } 0:100
my @y = map { sin(_) } @x
line_svg(\@x, \@y, "Sine") |> to_file("sine.svg")

# plot_svg

plot_svg — SVG line plot with auto X axis (0..n-1). Args: ys [, title].

plot_svg([map { _ ** 2 } 0:50], "Parabola") |> to_file("plot.svg")

# hist_svg

hist_svg (alias histogram_svg) — SVG histogram with auto-binning (sqrt rule). Args: data [, bins, title].

rnorm(1000) |> hist_svg(30, "Normal") |> to_file("hist.svg")

# boxplot_svg

boxplot_svg (alias box_plot) — SVG box-and-whisker plot with IQR whiskers and outlier detection. Args: groups [, title]. Groups is array of arrays.

boxplot_svg([[1,2,3,4,5], [3,4,5,6,20]], "Compare") |> to_file("box.svg")

# bar_svg

bar_svg (alias barchart_svg) — SVG bar chart with labeled bars and value annotations. Args: labels, values [, title].

bar_svg(["Rust","Go","C++"], [45,30,25], "Languages") |> to_file("bar.svg")

# pie_svg

pie_svg (alias pie_chart) — SVG pie chart with percentage labels. Args: labels, values [, title].

pie_svg(["A","B","C"], [50,30,20]) |> to_file("pie.svg")

# heatmap_svg

heatmap_svg (alias heatmap) — SVG heatmap with blue-cyan-yellow-red colormap. Args: matrix [, title].

heatmap_svg(cor_mat($data), "Correlation") |> to_file("heat.svg")

# donut_svg

donut_svg (alias donut) — SVG donut chart with percentage labels. Accepts labels+values or a hashref.

donut_svg(["A","B","C"], [50,30,20], "Share") |> to_file("donut.svg")
{Rust => 45, Go => 30} |> donut("Languages") |> to_file("donut.svg")

# area_svg

area_svg (alias area_chart) — SVG filled area chart. Args: xs, ys [, title].

my @x = 0:20
my @y = map { sin(_ * 0.3) } @x
area_svg(\@x, \@y, "Wave") |> to_file("area.svg")

# hbar_svg

hbar_svg (alias hbar) — SVG horizontal bar chart. Accepts labels+values or a hashref.

hbar_svg(["Rust","Go","C++"], [45,30,25], "Speed") |> to_file("hbar.svg")
{alpha => 10, beta => 20} |> hbar |> to_file("hbar.svg")

# radar_svg

radar_svg (aliases radar, spider) — SVG radar/spider chart. Args: labels, values [, title].

radar_svg(["Atk","Def","Spd","HP","MP"], [8,6,9,5,7], "Stats") |> to_file("radar.svg")

# candlestick_svg

candlestick_svg (aliases candlestick, ohlc) — SVG candlestick OHLC chart. Args: array of [open,high,low,close] [, title].

candlestick_svg([[100,110,95,105],[105,115,100,112]], "Stock") |> to_file("ohlc.svg")

# violin_svg

violin_svg (alias violin) — SVG violin plot from array of arrays showing distribution shape.

violin_svg([rnorm(200), rnorm(200, 2)], "Distributions") |> to_file("violin.svg")

# cor_heatmap

cor_heatmap (alias cor_matrix_svg) — SVG correlation matrix heatmap. Computes pairwise correlations and renders as heatmap.

cor_heatmap([rnorm(100), rnorm(100), rnorm(100)], "Correlations") |> to_file("cor.svg")

# stacked_bar_svg

stacked_bar_svg (alias stacked_bar) — SVG stacked bar chart. Args: labels, series (array of arrays) [, title].

stacked_bar_svg(["Q1","Q2","Q3"], [[10,20,30],[5,15,25]], "Revenue") |> to_file("stacked.svg")

# wordcloud_svg

wordcloud_svg (aliases wordcloud, wcloud) — SVG word cloud from frequency hashref. Word size scales with frequency.

{rust => 50, go => 30, python => 40} |> wordcloud("Languages") |> to_file("cloud.svg")

# treemap_svg

treemap_svg (alias treemap) — SVG treemap from frequency hashref. Area proportional to values.

{src => 500, tests => 200, docs => 100} |> treemap("Codebase") |> to_file("tree.svg")

# preview

preview (alias pvw) — wrap SVG/HTML content in a cyberpunk-styled page and open in the default browser.

scatter_svg([1,2,3], [1,4,9]) |> preview
bar_svg(["A","B"], [10,20]) |> pvw

# audio_convert

audio_convert (alias aconv) — convert audio files between WAV, FLAC, AIFF, and MP3 formats.

audio_convert("song.flac", "song.mp3")
aconv("input.wav", "output.mp3")

# audio_info

audio_info (alias ainfo) — get audio file metadata (duration, sample rate, channels, format) as a hashref.

my $info = ainfo("song.mp3")
p $info->{duration}      # seconds
p $info->{sample_rate}   # e.g. 44100

# id3_read

id3_read (alias id3) — read ID3 tags from an MP3 file as a hashref (title, artist, album, year, etc.).

my $tags = id3("song.mp3")
p "$tags->{artist} - $tags->{title}"

# id3_write

id3_write (alias id3w) — write ID3 tags to an MP3 file from a hashref.

id3w("song.mp3", {title => "New Title", artist => "Artist", year => "2026"})

# net_interfaces

net_interfaces (aliases net_ifs, ifconfig) — list all network interfaces with name, IPs, MAC, and status.

my @ifs = net_ifs()
for (@ifs) { p "_->{name}: _->{ipv4}" }

# net_ipv4

net_ipv4 (aliases myip, myip4) — return the first non-loopback IPv4 address as a string.

p myip()   # e.g. 192.168.1.42

# net_ipv6

net_ipv6 (alias myip6) — return the first non-loopback IPv6 address as a string.

p myip6()   # e.g. fe80::1

# net_mac

net_mac (alias mymac) — return the first non-loopback MAC address.

p mymac()   # e.g. aa:bb:cc:dd:ee:ff

# net_public_ip

net_public_ip (aliases pubip, extip) — fetch your public IP address via HTTP.

p pubip()   # e.g. 203.0.113.42

# net_dns

net_dns (aliases dns_resolve, resolve) — resolve a hostname to IP addresses.

my @ips = resolve("github.com")
p @ips

# net_reverse_dns

net_reverse_dns (alias rdns) — reverse DNS lookup via UDP PTR query.

p rdns("8.8.8.8")   # dns.google

# net_ping

net_ping (alias ping) — TCP connect ping to host:port. Returns array of RTT measurements in ms.

my @rtt = ping("google.com", 443, 5)   # 5 pings
p mean(@rtt)

# net_port_open

net_port_open (alias port_open) — check if a TCP port is open on a host. Returns boolean.

p port_open("localhost", 8080)   # 1 or 0

# net_ports_scan

net_ports_scan (aliases port_scan, portscan) — scan a range of TCP ports on a host. Returns list of open ports.

my @open = port_scan("localhost", 80, 443)
p @open   # e.g. 80, 443

# net_latency

net_latency (alias tcplat) — measure TCP connect latency to host:port in milliseconds.

p tcplat("google.com", 443)   # e.g. 12.5

# net_download

net_download (aliases download, wget) — download a URL to a local file via ureq.

wget("https://example.com/data.csv", "data.csv")

# net_headers

net_headers (alias http_headers) — fetch HTTP response headers as a hashref.

my $h = http_headers("https://example.com")
p $h->{"content-type"}

# net_dns_servers

net_dns_servers (alias dns_servers) — return the system's configured DNS server addresses.

my @dns = dns_servers()
p @dns   # e.g. 8.8.8.8, 8.8.4.4

# net_gateway

net_gateway (alias gateway) — return the default gateway IP address.

p gateway()   # e.g. 192.168.1.1

# net_whois

net_whois (alias whois) — WHOIS lookup via raw TCP connection on port 43.

p whois("example.com")

# net_hostname

net_hostname — return the system hostname.

p net_hostname()   # e.g. my-macbook.local

# smtp_send

smtp_send (aliases send_email, email) — send an email via SMTP with TLS. Takes a hashref with to, from, subject, body, and SMTP connection fields.

smtp_send({to => "bob@ex.com", from => "me@ex.com", subject => "Hi",
  body => "Hello!", smtp_host => "smtp.ex.com", smtp_port => 587,
  smtp_user => "me@ex.com", smtp_pass => $pass})

# html_parse

html_parse (alias parse_html) — parse an HTML string into an array of element hashrefs with tag, text, and attrs.

my @els = html_parse(slurp("page.html"))
for (@els) { p "_->{tag}: _->{text}" }

# css_select

css_select (aliases css, qs, query_selector) — query parsed HTML with a CSS selector. Returns matching elements as hashrefs with tag, text, attrs, and html.

my @links = css_select(slurp("page.html"), "a.nav")
for (@links) { p "_->{tag} _->{attrs}{href}" }

# xml_parse

xml_parse (alias parse_xml) — parse an XML string into a nested hashref tree with tag, text, attrs, and children.

my $root = xml_parse(slurp("data.xml"))
p $root->{tag}
for (@{$root->{children}}) { p _->{text} }

# xpath

xpath (alias xml_select) — query XML with XPath-like expressions (//tag, //tag[@attr='val']). Returns matching nodes as hashrefs.

my @items = xpath(slurp("feed.xml"), "//item")
for (@items) { p _->{text} }

# dateseq

dateseq (alias dseq) — generate a sequence of dates. Args: start, end [, step]. Step defaults to 1 day.

my @days = dseq("2026-01-01", "2026-01-07")
p @days

# dategrep

dategrep (alias dgrep) — filter a list of date strings by a pattern or range.

my @jan = dgrep("2026-01", @dates)

# dateround

dateround (alias dround) — round date strings to a unit (day, hour, month, etc.).

p dround("2026-04-19T14:35:22", "hour")   # 2026-04-19T15:00:00

# datesort

datesort (alias dsort) — sort date strings chronologically.

my @sorted = dsort("2026-03-01", "2026-01-15", "2026-02-10")
p @sorted

# git_log

git_log (alias glog) — get the last N commits as an array of hashrefs (hash, author, date, message).

my @commits = glog(10)
for (@commits) { p "_->{hash} _->{message}" }

# git_status

git_status (alias gst) — get working tree status as an array of hashrefs (path, status).

my @st = gst()
for (@st) { p "_->{status} _->{path}" }

# git_diff

git_diff (alias gdiff) — get the current diff as a string.

p gdiff()
gdiff() |> lines |> grep /^\+/ |> e p

# git_branches

git_branches (alias gbr) — list all branches as an array of strings.

my @br = gbr()
p @br

# git_tags

git_tags (alias gtags) — list all tags as an array of strings.

my @tags = gtags()
p @tags

# git_blame

git_blame (alias gblame) — blame a file, returning per-line annotation.

p gblame("src/main.rs")

# git_authors

git_authors (alias gauthors) — list unique authors sorted by commit count as hashrefs.

my @authors = gauthors()
for (@authors) { p "_->{name}: _->{count}" }

# git_files

git_files (alias gfiles) — list all tracked files in the repo.

my @files = gfiles()
p scalar @files   # total tracked files

# git_show

git_show (alias gshow) — show details of a commit (message, diff, author).

p gshow("HEAD")
p gshow("abc1234")

# git_root

git_root (alias groot) — return the repository root path.

p groot()   # e.g. /home/user/project

# mounts

mounts (aliases disk_mounts, filesystems) — list mounted filesystems with usage (total, used, available).

my @m = mounts()
for (@m) { p "_->{mount}: _->{used}/_->{total}" }

# thread_count

thread_count (alias nthreads) — return the rayon thread pool size.

p nthreads()   # e.g. 8

# pool_info

pool_info (alias par_info) — return thread pool details as a hashref (threads, queued, active).

my $info = par_info()
p $info->{threads}

# par_bench

par_bench (alias pbench) — run a parallel throughput benchmark and return results.

my $result = pbench(1000000)
p $result->{ops_per_sec}

# to_pdf

to_pdf — generate a PDF from text, SVG, or structured data. Returns raw PDF bytes.

"Hello World" |> to_pdf |> to_file("out.pdf")
scatter_svg([1,2,3], [1,4,9]) |> to_pdf |> to_file("plot.pdf")

# pdf_text

pdf_text (aliases pdf_read, pdf_extract) — extract all text content from a PDF file and return it as a string.

my $text = pdf_text("report.pdf")
p $text |> lines |> cnt   # number of lines

# pdf_pages

pdf_pages — return the number of pages in a PDF file.

p pdf_pages("report.pdf")   # e.g. 42

# jq

jq — alias for json_jq. Query JSON data with jq-style expressions.

my $data = json_decode(slurp("data.json"))
p jq($data, ".items[].name")

# assert_eq

assert_eq (alias aeq) — assert that two values are equal as strings. Takes A, B, and an optional message. Fails the test with a diff if A ne B.

assert_eq $got, $expected, "username matches"
aeq length(@arr), 3

# assert_ne

assert_ne (alias ane) — assert that two values are not equal as strings. Takes A, B, and an optional message. Fails if A eq B.

assert_ne $token, "", "token must not be empty"
ane $a, $b

# assert_ok

assert_ok (alias aok) — assert that a value is truthy (defined and non-zero/non-empty). Fails if the value is falsy or undef.

assert_ok $result, "fetch returned data"
aok $user->{active}

# assert_err

assert_err — assert that a value is falsy or undef. The inverse of assert_ok. Useful for verifying error conditions or absent values.

assert_err $deleted_user, "user should be gone"
assert_err 0

# assert_true

assert_true (alias atrue) — alias for assert_ok. Assert that a value is truthy.

assert_true $connected, "should be connected"
atrue $flag

# assert_false

assert_false (alias afalse) — alias for assert_err. Assert that a value is falsy or undef.

assert_false $error, "no error expected"
afalse $disabled

# assert_gt

assert_gt — assert that the first numeric value is strictly greater than the second. Fails with the actual values on mismatch.

assert_gt $elapsed, 0, "elapsed must be positive"
assert_gt scalar(@results), 10

# assert_lt

assert_lt — assert that the first numeric value is strictly less than the second.

assert_lt $latency, 100, "latency under 100ms"
assert_lt $errors, $threshold

# assert_ge

assert_ge — assert that the first numeric value is greater than or equal to the second.

assert_ge $count, 1, "at least one result"
assert_ge $version, 2

# assert_le

assert_le — assert that the first numeric value is less than or equal to the second.

assert_le $memory, $limit, "within memory budget"
assert_le length($buf), 4096

# assert_match

assert_match (alias amatch) — assert that a string matches a regex pattern. Fails with the actual string and pattern on mismatch.

assert_match $email, qr/\@/, "must contain @"
amatch $line, qr/^OK/

# assert_contains

assert_contains (alias acontains) — assert that a string contains a given substring. Fails with both values on mismatch.

assert_contains $html, "<title>", "page has title"
acontains $log, "SUCCESS"

# assert_near

assert_near (alias anear) — assert that two floats are approximately equal within an epsilon tolerance (default 1e-9). Essential for floating-point comparisons.

assert_near 0.1 + 0.2, 0.3, 1e-10, "float add"
anear $pi, 3.14159, 1e-5

# assert_dies

assert_dies (alias adies) — assert that a block throws an error. Passes if the block dies, fails if it returns normally.

assert_dies { die "boom" } "should throw"
adies { 1 / 0 }

# test_run

test_run (alias run_tests) — print a test summary with pass/fail counts and exit with code 1 if any test failed. Call at the end of a test file to report results.

# ... assertions above ...
test_run   # prints summary, exits 1 on failure

# __stryke_rust_compile

__stryke_rust_compile — internal builtin.

my $result = __stryke_rust_compile $x 
# or in a pipeline:
@list |> map __stryke_rust_compile |> p

# a0

bohr_radius (alias a0) — a₀ ≈ 5.29×10⁻¹¹ m. Radius of hydrogen atom ground state.

p a0   # 5.29177210903e-11

# a256

a256 — color operations builtin. Alias for ansi_256.

my $result = a256 $x 
# or in a pipeline:
@list |> map a256 |> p

# a85d

base85_decode (aliases b85d, a85d) decodes an Ascii85/Base85 encoded string.

p b85d(b85e("Hello"))  # Hello

# a85e

base85_encode (aliases b85e, a85e) encodes a string using Ascii85/Base85 encoding. More compact than Base64 (4:5 ratio vs 3:4).

p b85e("Hello")  # encoded string

# abs_ceil

abs_ceil — trivial numeric helpers (batch 4) builtin.

my $result = abs_ceil $x 
# or in a pipeline:
@list |> map abs_ceil |> p

# abs_diff

abs_diff — trivial numeric / predicate builtins builtin.

my $result = abs_diff $x 
# or in a pipeline:
@list |> map abs_diff |> p

# abs_each

abs_each — trivial numeric helpers (batch 4) builtin.

my $result = abs_each $x 
# or in a pipeline:
@list |> map abs_each |> p

# abs_floor

abs_floor — trivial numeric helpers (batch 4) builtin.

my $result = abs_floor $x 
# or in a pipeline:
@list |> map abs_floor |> p

# abundant_numbers

abundant_numbers — number theory / primes builtin.

my $result = abundant_numbers $x 
# or in a pipeline:
@list |> map abundant_numbers |> p

# abunnums

abunnums — number theory / primes builtin. Alias for abundant_numbers.

my $result = abunnums $x 
# or in a pipeline:
@list |> map abunnums |> p

# accum

accum — python/ruby stdlib builtin. Alias for accumulate.

my $result = accum $x 
# or in a pipeline:
@list |> map accum |> p

# accumulate

accumulate — python/ruby stdlib builtin.

my $result = accumulate $x 
# or in a pipeline:
@list |> map accumulate |> p

# acf

acf_fn (alias acf) — autocorrelation function. Returns ACF values for lags 0..max_lag. Like R's acf().

my @a = @{acf([1,3,2,4,3,5,4,6], 5)}
p $a[0]  # 1.0 (lag 0 is always 1)
p $a[1]  # lag-1 autocorrelation

# acirc

acirc — geometry / physics builtin. Alias for area_circle.

my $result = acirc $x 
# or in a pipeline:
@list |> map acirc |> p

# acorr

acorr — math / numeric (uncategorized batch) builtin. Alias for autocorrelation.

my $result = acorr $x 
# or in a pipeline:
@list |> map acorr |> p

# acos

acos — trig / math (batch 2) builtin.

my $result = acos $x 
# or in a pipeline:
@list |> map acos |> p

# acosh

acosh — trig / math (batch 2) builtin.

my $result = acosh $x 
# or in a pipeline:
@list |> map acosh |> p

# acot

acot — trig extensions builtin.

my $result = acot $x 
# or in a pipeline:
@list |> map acot |> p

# acro

acro — string processing (uncategorized batch) builtin. Alias for acronym.

my $result = acro $x 
# or in a pipeline:
@list |> map acro |> p

# acronym

acronym — string processing (uncategorized batch) builtin.

my $result = acronym $x 
# or in a pipeline:
@list |> map acronym |> p

# acsc

acsc — trig extensions builtin.

my $result = acsc $x 
# or in a pipeline:
@list |> map acsc |> p

# add_days

add_days — extended stdlib builtin.

my $result = add_days $x 
# or in a pipeline:
@list |> map add_days |> p

# add_hours

add_hours — extended stdlib builtin.

my $result = add_hours $x 
# or in a pipeline:
@list |> map add_hours |> p

# add_minutes

add_minutes — extended stdlib builtin.

my $result = add_minutes $x 
# or in a pipeline:
@list |> map add_minutes |> p

# addd

addd — extended stdlib builtin. Alias for add_days.

my $result = addd $x 
# or in a pipeline:
@list |> map addd |> p

# addh

addh — extended stdlib builtin. Alias for add_hours.

my $result = addh $x 
# or in a pipeline:
@list |> map addh |> p

# addm

addm — extended stdlib builtin. Alias for add_minutes.

my $result = addm $x 
# or in a pipeline:
@list |> map addm |> p

# adjacent_difference

adjacent_difference — list helpers (batch 4) builtin.

my $result = adjacent_difference $x 
# or in a pipeline:
@list |> map adjacent_difference |> p

# adjacent_pairs

adjacent_pairs — go/general functional utilities builtin.

my $result = adjacent_pairs $x 
# or in a pipeline:
@list |> map adjacent_pairs |> p

# adjp

adjp — go/general functional utilities builtin. Alias for adjacent_pairs.

my $result = adjp $x 
# or in a pipeline:
@list |> map adjp |> p

# adl32

adl32 — extended stdlib builtin. Alias for adler32.

my $result = adl32 $x 
# or in a pipeline:
@list |> map adl32 |> p

# adler32

adler32 — extended stdlib builtin.

my $result = adler32 $x 
# or in a pipeline:
@list |> map adler32 |> p

# aellip

aellip — geometry / physics builtin. Alias for area_ellipse.

my $result = aellip $x 
# or in a pipeline:
@list |> map aellip |> p

# after_n

after_n — functional combinators builtin.

my $result = after_n $x 
# or in a pipeline:
@list |> map after_n |> p

# age_in_years

age_in_years — extended stdlib batch 3 builtin.

my $result = age_in_years $x 
# or in a pipeline:
@list |> map age_in_years |> p

# ageyrs

ageyrs — extended stdlib batch 3 builtin. Alias for age_in_years.

my $result = ageyrs $x 
# or in a pipeline:
@list |> map ageyrs |> p

# ain

ain — algebraic match builtin. Alias for assoc_in.

my $result = ain $x 
# or in a pipeline:
@list |> map ain |> p

# aliquot

aliquot — math / numeric (uncategorized batch) builtin. Alias for aliquot_sum.

my $result = aliquot $x 
# or in a pipeline:
@list |> map aliquot |> p

# aliquot_sum

aliquot_sum — math / numeric (uncategorized batch) builtin.

my $result = aliquot_sum $x 
# or in a pipeline:
@list |> map aliquot_sum |> p

# all_distinct

all_distinct — more list helpers builtin.

my $result = all_distinct $x 
# or in a pipeline:
@list |> map all_distinct |> p

# all_eq

all_eq — more list helpers builtin.

my $result = all_eq $x 
# or in a pipeline:
@list |> map all_eq |> p

# all_match

all_match — predicates (batch 4) builtin.

my $result = all_match $x 
# or in a pipeline:
@list |> map all_match |> p

# all_unique

all_unique — more list helpers builtin. Alias for all_distinct.

my $result = all_unique $x 
# or in a pipeline:
@list |> map all_unique |> p

# alpha_fs

fine_structure_constant (alias alpha_fs) — α ≈ 1/137 ≈ 0.00730. Fundamental constant of electromagnetism.

p alpha_fs       # 0.0072973525693
p 1 / alpha_fs   # ~137.036

# alternate_case

alternate_case — string helpers (batch 4) builtin.

my $result = alternate_case $x 
# or in a pipeline:
@list |> map alternate_case |> p

# always_false

always_false — functional primitives builtin.

my $result = always_false $x 
# or in a pipeline:
@list |> map always_false |> p

# always_true

always_true — functional primitives builtin.

my $result = always_true $x 
# or in a pipeline:
@list |> map always_true |> p

# amax

amax — extended stdlib builtin. Alias for argmax.

my $result = amax $x 
# or in a pipeline:
@list |> map amax |> p

# amin

amin — extended stdlib builtin. Alias for argmin.

my $result = amin $x 
# or in a pipeline:
@list |> map amin |> p

# amort

amortization_schedule($principal, $rate, $periods) (alias amort) — generates a full amortization schedule. Returns arrayref of hashrefs with period, payment, principal, interest, balance.

my $sched = amort(10000, 0.05, 12)
for my $row (@$sched) {
    p "Period $row->{period}: bal=$row->{balance}"
}

# amu

amu — physics constants builtin. Alias for atomic_mass_unit.

my $result = amu $x 
# or in a pipeline:
@list |> map amu |> p

# and

and — control flow builtin.

my $result = and $x 
# or in a pipeline:
@list |> map and |> p

# and_list

and_list — additional missing stdlib functions builtin.

my $result = and_list $x 
# or in a pipeline:
@list |> map and_list |> p

# andl

andl — additional missing stdlib functions builtin. Alias for and_list.

my $result = andl $x 
# or in a pipeline:
@list |> map andl |> p

# angbet

angbet — geometry (extended) builtin. Alias for angle_between.

my $result = angbet $x 
# or in a pipeline:
@list |> map angbet |> p

# angle_between

angle_between($x1, $y1, $x2, $y2) — computes the angle in radians between two 2D vectors from origin. Returns the angle using atan2.

my $angle = angle_between(1, 0, 0, 1)
p $angle   # ~1.5708 (π/2 radians = 90°)

# angle_between_deg

angle_between_deg — math functions builtin.

my $result = angle_between_deg $x 
# or in a pipeline:
@list |> map angle_between_deg |> p

# angle_bracket

angle_bracket — string helpers (batch 4) builtin.

my $result = angle_bracket $x 
# or in a pipeline:
@list |> map angle_bracket |> p

# angular_velocity

angular_velocity — physics formulas builtin.

my $result = angular_velocity $x 
# or in a pipeline:
@list |> map angular_velocity |> p

# angvel

angvel — physics formulas builtin. Alias for angular_velocity.

my $result = angvel $x 
# or in a pipeline:
@list |> map angvel |> p

# anova

anova_oneway (aliases anova, anova1) performs one-way ANOVA. Returns [F-statistic, df_between, df_within].

my ($F, $dfb, $dfw) = @{anova([1,2,3], [4,5,6], [7,8,9])}

# ansi_256

ansi_256 — color operations builtin.

my $result = ansi_256 $x 
# or in a pipeline:
@list |> map ansi_256 |> p

# ansi_black

ansi_black — color / ansi builtin.

my $result = ansi_black $x 
# or in a pipeline:
@list |> map ansi_black |> p

# ansi_blue

ansi_blue — color / ansi builtin.

my $result = ansi_blue $x 
# or in a pipeline:
@list |> map ansi_blue |> p

# ansi_bold

ansi_bold — color / ansi builtin.

my $result = ansi_bold $x 
# or in a pipeline:
@list |> map ansi_bold |> p

# ansi_cyan

ansi_cyan — color / ansi builtin.

my $result = ansi_cyan $x 
# or in a pipeline:
@list |> map ansi_cyan |> p

# ansi_dim

ansi_dim — color / ansi builtin.

my $result = ansi_dim $x 
# or in a pipeline:
@list |> map ansi_dim |> p

# ansi_green

ansi_green — color / ansi builtin.

my $result = ansi_green $x 
# or in a pipeline:
@list |> map ansi_green |> p

# ansi_magenta

ansi_magenta — color / ansi builtin.

my $result = ansi_magenta $x 
# or in a pipeline:
@list |> map ansi_magenta |> p

# ansi_off

ansi_off — color / ansi builtin. Alias for red.

my $result = ansi_off $x 
# or in a pipeline:
@list |> map ansi_off |> p

# ansi_red

ansi_red — color / ansi builtin.

my $result = ansi_red $x 
# or in a pipeline:
@list |> map ansi_red |> p

# ansi_reverse

ansi_reverse — color / ansi builtin.

my $result = ansi_reverse $x 
# or in a pipeline:
@list |> map ansi_reverse |> p

# ansi_truecolor

ansi_truecolor — color operations builtin.

my $result = ansi_truecolor $x 
# or in a pipeline:
@list |> map ansi_truecolor |> p

# ansi_underline

ansi_underline — color / ansi builtin.

my $result = ansi_underline $x 
# or in a pipeline:
@list |> map ansi_underline |> p

# ansi_white

ansi_white — color / ansi builtin.

my $result = ansi_white $x 
# or in a pipeline:
@list |> map ansi_white |> p

# ansi_yellow

ansi_yellow — color / ansi builtin.

my $result = ansi_yellow $x 
# or in a pipeline:
@list |> map ansi_yellow |> p

# any_match

any_match — predicates (batch 4) builtin.

my $result = any_match $x 
# or in a pipeline:
@list |> map any_match |> p

# apery

apery — math constants builtin. Alias for apery_constant.

my $result = apery $x 
# or in a pipeline:
@list |> map apery |> p

# apery_constant

apery_constant — math constants builtin.

my $result = apery_constant $x 
# or in a pipeline:
@list |> map apery_constant |> p

# append_elem

append_elem — list helpers (batch 4) builtin.

my $result = append_elem $x 
# or in a pipeline:
@list |> map append_elem |> p

# appl

appl — algebraic match builtin. Alias for apply.

my $result = appl $x 
# or in a pipeline:
@list |> map appl |> p

# apply

apply — algebraic match builtin.

my $result = apply $x 
# or in a pipeline:
@list |> map apply |> p

# apply_list

apply_list — functional combinators builtin.

my $result = apply_list $x 
# or in a pipeline:
@list |> map apply_list |> p

# apply_window

apply_window(\@signal, \@window) — element-wise multiplies signal by window function. Use before FFT to reduce spectral leakage.

my $w = hann(scalar @signal)
my $windowed = apply_window(\@signal, $w)
my $spectrum = dft($windowed)

# applywin

applywin — dsp / signal (extended) builtin. Alias for apply_window.

my $result = applywin $x 
# or in a pipeline:
@list |> map applywin |> p

# approx

approx_fn (alias approx) — piecewise linear interpolation at query points. Like R's approx().

my @y = @{approx([0,1,2], [0,10,0], [0.5, 1.0, 1.5])}
# [5, 10, 5]

# approx_eq

approx_eq — math functions builtin.

my $result = approx_eq $x 
# or in a pipeline:
@list |> map approx_eq |> p

# apsp

floyd_warshall (aliases floydwarshall, apsp) computes all-pairs shortest paths. Takes a distance matrix (use Inf for no edge).

my $d = apsp([[0,3,1e18],[1e18,0,1],[1e18,1e18,0]])

# arange

arange — matrix / linear algebra builtin.

my $result = arange $x 
# or in a pipeline:
@list |> map arange |> p

# arc_length

arc_length($radius, $theta) — computes the arc length of a circular arc. Theta is the central angle in radians. Returns radius * theta.

p arc_length(10, 3.14159)   # ~31.4 (half circle)
p arc_length(5, 1.57)       # ~7.85 (quarter circle)

# arclen

arclen — geometry (extended) builtin. Alias for arc_length.

my $result = arclen $x 
# or in a pipeline:
@list |> map arclen |> p

# area_circle

area_circle — geometry / physics builtin.

my $result = area_circle $x 
# or in a pipeline:
@list |> map area_circle |> p

# area_ellipse

area_ellipse — geometry / physics builtin.

my $result = area_ellipse $x 
# or in a pipeline:
@list |> map area_ellipse |> p

# area_rectangle

area_rectangle — geometry / physics builtin.

my $result = area_rectangle $x 
# or in a pipeline:
@list |> map area_rectangle |> p

# area_trapezoid