<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<meta name="color-scheme" content="dark light">
<meta name="description" content="stryke full reference — every builtin, keyword, alias, and extension with its LSP hover doc rendered as a static page.">
<title>stryke — Reference</title>
<link rel="preconnect" href="https://fonts.googleapis.com">
<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
<link href="https://fonts.googleapis.com/css2?family=Orbitron:wght@400;600;700;900&family=Share+Tech+Mono&display=swap" rel="stylesheet">
<link rel="stylesheet" href="hud-static.css">
<link rel="stylesheet" href="tutorial.css">
<style>
.tutorial-main { max-width: 72rem; }
.docs-build-line {
margin: 0.35rem 0 0;
font-family: 'Share Tech Mono', ui-monospace, monospace;
font-size: 11px; color: var(--text-dim);
letter-spacing: 0.03em; max-width: 42rem; opacity: 0.75;
}
.hub-scheme-strip {
border-bottom: 1px dashed var(--border);
background: color-mix(in srgb, var(--bg-secondary) 85%, transparent);
padding: 0.55rem 1.5rem 0.65rem; position: relative;
}
.hub-scheme-strip-inner {
max-width: 72rem; margin: 0 auto;
display: flex; align-items: center; gap: 0.85rem;
}
.hub-scheme-strip .hud-scheme-label {
flex: 0 0 auto;
font-family: 'Orbitron', sans-serif; font-size: 9px; font-weight: 700;
letter-spacing: 2px; text-transform: uppercase; color: var(--accent);
}
.hub-scheme-strip .scheme-grid {
flex: 1 1 auto;
display: grid; grid-template-columns: repeat(5, minmax(0, 1fr)); gap: 6px;
}
@media (max-width: 720px) {
.hub-scheme-strip-inner { flex-direction: column; align-items: stretch; }
.hub-scheme-strip .scheme-grid { grid-template-columns: repeat(2, minmax(0, 1fr)); }
}
.chapter-index {
list-style: none; padding: 0; margin: 0;
display: grid; grid-template-columns: repeat(auto-fill, minmax(18rem, 1fr));
gap: 0.3rem;
}
.chapter-index li {
border: 1px solid var(--border); padding: 0.45rem 0.65rem; border-radius: 2px;
background: color-mix(in srgb, var(--bg-card) 92%, transparent);
display: flex; justify-content: space-between; align-items: baseline;
}
.chapter-index li a {
color: var(--cyan); text-decoration: none; font-size: 13px;
font-family: 'Share Tech Mono', ui-monospace, monospace;
}
.chapter-index li a:hover { color: var(--accent-light); }
.chapter-count {
font-size: 10px; color: var(--text-muted);
font-family: 'Share Tech Mono', ui-monospace, monospace;
}
.chapter-meta {
font-size: 11px; color: var(--text-muted); margin: -0.3rem 0 0.8rem;
font-family: 'Share Tech Mono', ui-monospace, monospace;
}
.doc-entry {
margin: 1rem 0 1.4rem;
padding: 0.75rem 0.9rem 0.5rem;
border-left: 2px solid var(--cyan);
background: color-mix(in srgb, var(--bg) 94%, transparent);
border-radius: 2px;
}
.doc-entry h3 {
margin: 0 0 0.45rem;
font-family: 'Orbitron', sans-serif;
font-size: 13px; font-weight: 700; letter-spacing: 1.5px;
text-transform: uppercase; color: var(--cyan);
}
.doc-entry h3 code {
color: var(--accent-light); background: transparent; border: none;
padding: 0; font-size: 1em; letter-spacing: 0.5px;
}
.doc-entry .doc-anchor {
color: var(--text-muted); font-size: 0.85em; margin-right: 0.25rem;
text-decoration: none;
}
.doc-entry .doc-anchor:hover { color: var(--accent); }
.doc-entry h4 {
font-family: 'Orbitron', sans-serif;
font-size: 11px; font-weight: 700; letter-spacing: 1.5px;
text-transform: uppercase; color: var(--accent-light);
margin: 0.8rem 0 0.3rem;
}
.doc-entry p {
font-size: 13px; line-height: 1.6; color: var(--text-dim);
margin: 0.35rem 0;
}
.doc-entry p code, .doc-entry li code {
color: var(--accent-light); font-size: 12px;
}
.doc-entry ul { margin: 0.3rem 0 0.5rem; padding-left: 1.25rem; }
.doc-entry li { font-size: 13px; color: var(--text-dim); line-height: 1.55; margin: 0.2rem 0; }
.doc-entry pre {
font-family: 'Share Tech Mono', ui-monospace, monospace;
font-size: 12px;
background: var(--bg); border: 1px solid var(--border);
border-radius: 2px;
padding: 0.7rem 0.9rem; overflow-x: auto;
color: var(--text); margin: 0.5rem 0;
box-shadow: inset 0 0 18px rgba(0, 0, 0, 0.35);
}
.doc-entry pre code { color: var(--text); background: transparent; border: none; padding: 0; }
[data-theme="light"] .doc-entry pre { box-shadow: inset 0 0 10px rgba(0, 0, 0, 0.05); }
kbd {
font-family: 'Share Tech Mono', ui-monospace, monospace;
font-size: 11px;
padding: 1px 6px;
background: var(--bg-secondary);
border: 1px solid var(--border);
border-bottom-width: 2px;
border-radius: 3px;
color: var(--cyan);
}
</style>
</head>
<body>
<div class="app tutorial-app" id="docsApp">
<div class="crt-scanline" id="crtH" aria-hidden="true"></div>
<div class="crt-scanline-v" id="crtV" aria-hidden="true"></div>
<header class="tutorial-header">
<div class="tutorial-header-inner">
<div>
<h1 class="tutorial-brand">// STRYKE — FULL REFERENCE</h1>
<nav class="tutorial-crumbs" aria-label="Breadcrumb">
<a href="index.html">Docs</a>
<span class="sep">/</span>
<span class="current">Reference</span>
<span class="sep">/</span>
<a href="https://github.com/MenkeTechnologies/stryke" target="_blank" rel="noopener noreferrer">GitHub</a>
</nav>
<p class="docs-build-line">stryke v0.8.3 · 3259 topics · 33 chapters · generated from <code>src/lsp.rs</code></p>
</div>
<div class="tutorial-toolbar">
<button type="button" class="btn btn-secondary" id="btnTheme" title="Toggle light/dark">Theme</button>
<button type="button" class="btn btn-secondary active" id="btnCrt" title="CRT scanline overlay">CRT</button>
<button type="button" class="btn btn-secondary active" id="btnNeon" title="Neon border pulse">Neon</button>
<a class="btn btn-secondary" href="index.html">Hub</a>
<a class="btn btn-secondary" href="https://github.com/MenkeTechnologies/stryke" target="_blank" rel="noopener noreferrer">GitHub</a>
</div>
</div>
</header>
<div class="hub-scheme-strip">
<div class="hub-scheme-strip-inner">
<span class="hud-scheme-label">// Color scheme</span>
<div class="scheme-grid" id="hudSchemeGrid"></div>
</div>
</div>
<main class="tutorial-main">
<h2 class="tutorial-title"><span class="step-hash">>_</span>LANGUAGE REFERENCE</h2>
<p class="tutorial-subtitle">Every builtin, keyword, alias, and extension with an LSP hover doc — rendered from the exact markdown that `stryke docs` shows in the terminal. Jump via the chapter index, or <kbd>Ctrl+F</kbd> for a specific name.</p>
<section class="tutorial-section">
<h2>Chapters</h2>
<ul class="chapter-index">
<li><a href="#ch-parallel-primitives">Parallel Primitives</a> <span class="chapter-count">18</span></li>
<li><a href="#ch-shared-state-concurrency">Shared State & Concurrency</a> <span class="chapter-count">11</span></li>
<li><a href="#ch-pipeline-pipe-forward">Pipeline & Pipe-Forward</a> <span class="chapter-count">6</span></li>
<li><a href="#ch-streaming-iterators">Streaming Iterators</a> <span class="chapter-count">24</span></li>
<li><a href="#ch-list-operations">List Operations</a> <span class="chapter-count">62</span></li>
<li><a href="#ch-stryke-extensions">stryke Extensions</a> <span class="chapter-count">19</span></li>
<li><a href="#ch-data-serialization">Data & Serialization</a> <span class="chapter-count">45</span></li>
<li><a href="#ch-http-networking">HTTP & Networking</a> <span class="chapter-count">23</span></li>
<li><a href="#ch-crypto-encoding">Crypto & Encoding</a> <span class="chapter-count">133</span></li>
<li><a href="#ch-special-math-functions">Special Math Functions</a> <span class="chapter-count">12</span></li>
<li><a href="#ch-parallel-i-o">Parallel I/O</a> <span class="chapter-count">8</span></li>
<li><a href="#ch-file-i-o">File I/O</a> <span class="chapter-count">35</span></li>
<li><a href="#ch-strings">Strings</a> <span class="chapter-count">26</span></li>
<li><a href="#ch-arrays-hashes">Arrays & Hashes</a> <span class="chapter-count">19</span></li>
<li><a href="#ch-control-flow">Control Flow</a> <span class="chapter-count">17</span></li>
<li><a href="#ch-error-handling">Error Handling</a> <span class="chapter-count">8</span></li>
<li><a href="#ch-declarations">Declarations</a> <span class="chapter-count">11</span></li>
<li><a href="#ch-cluster-distributed">Cluster / Distributed</a> <span class="chapter-count">4</span></li>
<li><a href="#ch-datetime">Datetime</a> <span class="chapter-count">15</span></li>
<li><a href="#ch-math">Math</a> <span class="chapter-count">13</span></li>
<li><a href="#ch-file-system">File System</a> <span class="chapter-count">34</span></li>
<li><a href="#ch-process">Process</a> <span class="chapter-count">21</span></li>
<li><a href="#ch-pack-binary">Pack / Binary</a> <span class="chapter-count">3</span></li>
<li><a href="#ch-logging">Logging</a> <span class="chapter-count">7</span></li>
<li><a href="#ch-charts-svg">Charts (SVG)</a> <span class="chapter-count">19</span></li>
<li><a href="#ch-audio">Audio</a> <span class="chapter-count">4</span></li>
<li><a href="#ch-network-utilities">Network Utilities</a> <span class="chapter-count">18</span></li>
<li><a href="#ch-markup-web-scraping">Markup / Web Scraping</a> <span class="chapter-count">4</span></li>
<li><a href="#ch-date-utilities">Date Utilities</a> <span class="chapter-count">4</span></li>
<li><a href="#ch-git">Git</a> <span class="chapter-count">10</span></li>
<li><a href="#ch-system">System</a> <span class="chapter-count">8</span></li>
<li><a href="#ch-testing">Testing</a> <span class="chapter-count">15</span></li>
<li><a href="#ch-other">Other</a> <span class="chapter-count">2603</span></li>
</ul>
</section>
<section class="tutorial-section" id="ch-parallel-primitives">
<h2>Parallel Primitives</h2>
<p class="chapter-meta">18 topics</p>
<article class="doc-entry" id="doc-pmap">
<h3><a class="doc-anchor" href="#doc-pmap">#</a> <code>pmap</code></h3>
<p>Parallel <code>map</code> 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 <code>progress => 1</code> to get a live progress bar on STDERR for long-running jobs.</p>
<p>Two equivalent surface syntaxes: • Block form — <code>pmap BLOCK LIST</code> — element bound to <code>_</code> (bare <code>_</code> = <code>$_</code>) • Bare-fn form — <code>pmap FUNC, LIST</code> — single-arg function name as first argument</p>
<pre><code class="lang-perl"># Block form (bare _ is shorthand for $_)
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)
</code></pre>
</article>
<article class="doc-entry" id="doc-pmaps">
<h3><a class="doc-anchor" href="#doc-pmaps">#</a> <code>pmaps</code></h3>
<p>Streaming parallel <code>map</code> — returns a lazy iterator that processes items across all CPU cores using a persistent worker-thread pool. Unlike <code>pmap</code> which eagerly collects all results into an array, <code>pmaps</code> 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 <code>pmap</code> for large inputs.</p>
<p>Best for: • Pipelines with <code>take</code>/<code>head</code> — avoids processing the full list • Very large inputs where holding all results in memory is impractical • Streaming pipelines where you want progressive output</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-pmap-chunked">
<h3><a class="doc-anchor" href="#doc-pmap-chunked">#</a> <code>pmap_chunked</code></h3>
<p>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 <code>pmap</code> when profiling shows rayon overhead dominates the actual computation.</p>
<pre><code class="lang-perl">my @out = pmap_chunked 100, { _ ** 2 } 1..1_000_000
my @parsed = pmap_chunked 50, { json_decode } @json_strings
</code></pre>
</article>
<article class="doc-entry" id="doc-pgrep">
<h3><a class="doc-anchor" href="#doc-pgrep">#</a> <code>pgrep</code></h3>
<p>Parallel <code>grep</code> 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 <code>grep</code> 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 <code>grep</code> may be faster due to lower scheduling overhead.</p>
<p>Two equivalent surface syntaxes: <code>pgrep { BLOCK } LIST</code> or <code>pgrep FUNC, LIST</code>.</p>
<pre><code class="lang-perl"># 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)
</code></pre>
</article>
<article class="doc-entry" id="doc-pgreps">
<h3><a class="doc-anchor" href="#doc-pgreps">#</a> <code>pgreps</code></h3>
<p>Streaming parallel <code>grep</code> — returns a lazy iterator that filters items across all CPU cores. Unlike <code>pgrep</code> which eagerly collects all matching items, <code>pgreps</code> 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.</p>
<pre><code class="lang-perl">range(0, 1e6) |> pgreps { is_prime(_) } |> take 100 |> ep
t 1..1e9 pgreps { _ % 7 == 0 } take 10 ep
</code></pre>
</article>
<article class="doc-entry" id="doc-pfor">
<h3><a class="doc-anchor" href="#doc-pfor">#</a> <code>pfor</code></h3>
<p>Parallel <code>foreach</code> 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 <code>_</code> (or <code>$_</code>). Iteration order is non-deterministic, so the block must be safe to run concurrently.</p>
<p>Two equivalent surface syntaxes: <code>pfor { BLOCK } LIST</code> or <code>pfor FUNC, LIST</code>.</p>
<pre><code class="lang-perl"># 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)
</code></pre>
</article>
<article class="doc-entry" id="doc-psort">
<h3><a class="doc-anchor" href="#doc-psort">#</a> <code>psort</code></h3>
<p>Parallel sort that uses rayon's parallel merge-sort algorithm. Accepts an optional comparator block using <code>$_0</code>/<code>$_1</code> (or <code>$a</code>/<code>$b</code>). For large lists (10k+ elements), this significantly outperforms the sequential <code>sort</code> by splitting the array, sorting partitions in parallel, and merging. The sort is stable — equal elements retain their relative order.</p>
<pre><code class="lang-perl">my @sorted = psort { $_0 <=> $_1 } @big_list
my @by_name = psort { $_0->{name} cmp $_1->{name} } @records
@nums |> psort { $a <=> $b } |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-pcache">
<h3><a class="doc-anchor" href="#doc-pcache">#</a> <code>pcache</code></h3>
<p>Parallel memoized map — each element is processed concurrently, but results are cached by the stringified value of <code>$_</code> 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.</p>
<p>Two equivalent surface syntaxes: <code>pcache { BLOCK } LIST</code> or <code>pcache FUNC, LIST</code>.</p>
<pre><code class="lang-perl"># 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
</code></pre>
</article>
<article class="doc-entry" id="doc-preduce">
<h3><a class="doc-anchor" href="#doc-preduce">#</a> <code>preduce</code></h3>
<p>Parallel tree-fold using rayon's <code>reduce</code> — splits the list into chunks, reduces each chunk independently, then merges partial results. The combining operation **must be associative** (e.g. <code>+</code>, <code>*</code>, <code>max</code>); non-associative ops will produce incorrect results. Much faster than sequential <code>reduce</code> on large numeric lists because the tree structure allows O(log n) merge depth across cores.</p>
<pre><code class="lang-perl">my $total = preduce { $_0 + $_1 } @nums
my $biggest = preduce { $_0 > $_1 ? $_0 : $_1 } @vals
my $product = preduce { $a * $b } 1..100
</code></pre>
</article>
<article class="doc-entry" id="doc-preduce-init">
<h3><a class="doc-anchor" href="#doc-preduce-init">#</a> <code>preduce_init</code></h3>
<p>Parallel fold with identity value.</p>
<pre><code class="lang-perl">my $total = preduce_init 0, { $_0 + $_1 } @list
</code></pre>
</article>
<article class="doc-entry" id="doc-pmap-reduce">
<h3><a class="doc-anchor" href="#doc-pmap-reduce">#</a> <code>pmap_reduce</code></h3>
<p>Fused parallel map + tree reduce.</p>
<pre><code class="lang-perl">my $sum = pmap_reduce { _*2 } { $_0 + $_1 } @list
</code></pre>
</article>
<article class="doc-entry" id="doc-pany">
<h3><a class="doc-anchor" href="#doc-pany">#</a> <code>pany</code></h3>
<p><code>pany { COND } @list</code> — parallel short-circuit <code>any</code>.</p>
</article>
<article class="doc-entry" id="doc-pfirst">
<h3><a class="doc-anchor" href="#doc-pfirst">#</a> <code>pfirst</code></h3>
<p><code>pfirst { COND } @list</code> — parallel first matching element.</p>
</article>
<article class="doc-entry" id="doc-puniq">
<h3><a class="doc-anchor" href="#doc-puniq">#</a> <code>puniq</code></h3>
<p><code>puniq @list</code> — parallel unique elements.</p>
</article>
<article class="doc-entry" id="doc-pflat-map">
<h3><a class="doc-anchor" href="#doc-pflat-map">#</a> <code>pflat_map</code></h3>
<p>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.</p>
<p>Two equivalent surface syntaxes: <code>pflat_map BLOCK LIST</code> or <code>pflat_map FUNC, LIST</code>.</p>
<pre><code class="lang-perl"># 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)
</code></pre>
</article>
<article class="doc-entry" id="doc-pflat-maps">
<h3><a class="doc-anchor" href="#doc-pflat-maps">#</a> <code>pflat_maps</code></h3>
<p>Streaming parallel flat-map — like <code>pmaps</code> but flattens array results. Returns a lazy iterator.</p>
<pre><code class="lang-perl">range(0, 1e6) |> pflat_maps { [_, _ * 10] } |> ep
</code></pre>
</article>
<article class="doc-entry" id="doc-fan">
<h3><a class="doc-anchor" href="#doc-fan">#</a> <code>fan</code></h3>
<p>Execute BLOCK or FUNC N times in parallel (<code>_</code>/<code>$_0</code> = index 0..N-1). With no count, defaults to the rayon pool size (<code>stryke -j</code>).</p>
<p>Two equivalent surface syntaxes: • Block form — <code>fan N { BLOCK }</code> or <code>fan { BLOCK }</code> • Bare-fn form — <code>fan N, FUNC</code> or <code>fan FUNC</code></p>
<pre><code class="lang-perl"># 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
</code></pre>
</article>
<article class="doc-entry" id="doc-fan-cap">
<h3><a class="doc-anchor" href="#doc-fan-cap">#</a> <code>fan_cap</code></h3>
<p>Like <code>fan</code> but captures return values in index order. Two surface syntaxes: <code>fan_cap N { BLOCK }</code> or <code>fan_cap N, FUNC</code>.</p>
<pre><code class="lang-perl"># Block form
my @results = fan_cap 8 { compute($_) }
# Bare-fn form
sub compute { $_0 * $_0 }
my @squares = fan_cap 8, compute
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-shared-state-concurrency">
<h2>Shared State & Concurrency</h2>
<p class="chapter-meta">11 topics</p>
<article class="doc-entry" id="doc-mysync">
<h3><a class="doc-anchor" href="#doc-mysync">#</a> <code>mysync</code></h3>
<p>Declare shared variables for parallel blocks (<code>Arc<Mutex></code>).</p>
<pre><code class="lang-perl">mysync $counter = 0
fan 10000 { $counter++ } # always exactly 10000
mysync @results
mysync %histogram$1
Compound ops (`++`, `+=`, `.=`, `|=`, `&=`) are fully atomic.
</code></pre>
</article>
<article class="doc-entry" id="doc-async">
<h3><a class="doc-anchor" href="#doc-async">#</a> <code>async</code></h3>
<p><code>async { BLOCK }</code> — schedule a block for execution on a background worker thread and return a task handle immediately.</p>
<p>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 <code>await</code>, which blocks until the task completes and returns its value. If the block panics, the panic is captured and re-raised at the <code>await</code> call site. Use <code>async</code> 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 <code>fan</code> or <code>fan_cap</code> instead.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-spawn">
<h3><a class="doc-anchor" href="#doc-spawn">#</a> <code>spawn</code></h3>
<p><code>spawn { BLOCK }</code> — Rust-style alias for <code>async</code>; schedules a block on a background thread and returns a joinable task handle.</p>
<p>This is identical to <code>async</code> in every respect — same thread pool, same semantics, same <code>await</code> for joining. The name exists for developers coming from Rust's <code>tokio::spawn</code> or <code>std::thread::spawn</code> who find <code>spawn</code> more natural. Use whichever reads better in your code; mixing <code>async</code> and <code>spawn</code> in the same program is perfectly fine since they share the same underlying pool.</p>
<pre><code class="lang-perl">my $task = spawn { expensive_io() }
my $val = await $task
my @handles = map { spawn { process } } @items
my @out = map await @handles
</code></pre>
</article>
<article class="doc-entry" id="doc-await">
<h3><a class="doc-anchor" href="#doc-await">#</a> <code>await</code></h3>
<p><code>await $task</code> — block the current thread until an async/spawn task completes and return its result value.</p>
<p>If the background task has already finished by the time <code>await</code> is called, the result is returned immediately with no scheduling overhead. If the task panicked, <code>await</code> re-raises the panic as a die in the calling thread, preserving the original error message and backtrace. You can <code>await</code> a task exactly once; calling <code>await</code> 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 <code>join_all</code> primitive, but <code>map await @tasks</code> achieves the same effect.</p>
<pre><code class="lang-perl">my $task = async { 42 }
my $result = await $task # 42
# Await with error handling:
my $t = spawn { die "oops" }
eval { await $t } # $@ eq "oops"
</code></pre>
</article>
<article class="doc-entry" id="doc-pchannel">
<h3><a class="doc-anchor" href="#doc-pchannel">#</a> <code>pchannel</code></h3>
<p><code>pchannel(N)</code> — create a bounded multi-producer multi-consumer (MPMC) channel with capacity N, returning a <code>($tx, $rx)</code> pair.</p>
<p>The transmitter <code>$tx</code> supports <code>->send($val)</code> which blocks if the channel is full (backpressure). The receiver <code>$rx</code> supports <code>->recv</code> which blocks until a value is available, and <code>->try_recv</code> which returns <code>undef</code> immediately if the channel is empty. Both ends can be cloned and shared across threads — clone <code>$tx</code> with <code>$tx->clone</code> to create additional producers, or clone <code>$rx</code> for additional consumers. When all transmitters are dropped, <code>->recv</code> on the receiver returns <code>undef</code> to signal completion. Use <code>pchannel</code> to build producer-consumer pipelines, rate-limited work queues, or to communicate between <code>async</code>/<code>spawn</code> tasks.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-pselect">
<h3><a class="doc-anchor" href="#doc-pselect">#</a> <code>pselect</code></h3>
<p><code>pselect(@channels)</code> — wait on multiple <code>pchannel</code> receivers.</p>
</article>
<article class="doc-entry" id="doc-barrier">
<h3><a class="doc-anchor" href="#doc-barrier">#</a> <code>barrier</code></h3>
<p><code>barrier(N)</code> — create a synchronization barrier that blocks until exactly N threads have arrived at the wait point.</p>
<p>Each thread calls <code>$b->wait</code> 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 <code>std::sync::Barrier</code> for zero-overhead synchronization.</p>
<pre><code class="lang-perl">my $b = barrier(4)
for my $i (0..3) {
spawn {
setup_phase($i)
$b->wait # all 4 threads sync here
compute_phase($i)
}
}
</code></pre>
</article>
<article class="doc-entry" id="doc-ppool">
<h3><a class="doc-anchor" href="#doc-ppool">#</a> <code>ppool</code></h3>
<p><code>ppool(N, fn { ... })</code> — create a persistent thread pool of N worker threads, each running the provided subroutine in a loop.</p>
<p>The pool is typically paired with a <code>pchannel</code>: workers pull items from the channel's receiver, process them, and optionally send results to an output channel. Unlike <code>pmap</code> which is a one-shot parallel transform, <code>ppool</code> 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 <code>pmap</code> calls. Workers exit when their input channel is closed (all transmitters dropped). The pool object supports <code>->join</code> to block until all workers have finished.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-deque">
<h3><a class="doc-anchor" href="#doc-deque">#</a> <code>deque</code></h3>
<p><code>deque LIST</code> — create a double-ended queue initialized with the given elements.</p>
<p>A deque supports efficient O(1) insertion and removal at both ends via <code>->push_front($val)</code>, <code>->push_back($val)</code>, <code>->pop_front</code>, and <code>->pop_back</code>. It also supports <code>->len</code> and iteration. Internally backed by a Rust <code>VecDeque</code>, it is ideal for sliding window algorithms, BFS traversals, or any scenario where you need fast access to both ends of a sequence.</p>
<pre><code class="lang-perl">my $dq = deque(1, 2, 3)
$dq->push_front(0)
$dq->push_back(4)
p $dq->pop_front # 0
</code></pre>
</article>
<article class="doc-entry" id="doc-heap">
<h3><a class="doc-anchor" href="#doc-heap">#</a> <code>heap</code></h3>
<p><code>heap LIST</code> — create a min-heap (priority queue) from the given elements.</p>
<p>Elements are heapified on construction so that <code>->pop</code> always returns the smallest element in O(log n) time. <code>->push($val)</code> inserts a new element, also in O(log n). The heap supports <code>->peek</code> to inspect the minimum without removing it, and <code>->len</code> for the current size. Internally backed by a Rust <code>BinaryHeap</code> (inverted for min-heap semantics), it is the go-to structure for top-K queries, Dijkstra, and merge-K-sorted-lists problems.</p>
<pre><code class="lang-perl">my $h = heap(5, 3, 8, 1)
p $h->pop # 1 (smallest first)
p $h->peek # 3 (next smallest)
$h->push(0)
</code></pre>
</article>
<article class="doc-entry" id="doc-set">
<h3><a class="doc-anchor" href="#doc-set">#</a> <code>set</code></h3>
<p><code>set LIST</code> — create a set (unique unordered collection) from the given elements.</p>
<p>Duplicate values are collapsed on construction so the set contains each value exactly once. The set object provides <code>->contains($val)</code> for O(1) membership testing, plus <code>->union($s)</code>, <code>->intersection($s)</code>, <code>->difference($s)</code>, and <code>->len</code> methods. Internally backed by a Rust <code>HashSet</code> for performance. Use <code>to_set</code> to convert an existing iterator into a set.</p>
<pre><code class="lang-perl">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))
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-pipeline-pipe-forward">
<h2>Pipeline & Pipe-Forward</h2>
<p class="chapter-meta">6 topics</p>
<article class="doc-entry" id="doc-">
<h3><a class="doc-anchor" href="#doc-">#</a> <code>|></code></h3>
<p>Pipe-forward operator — threads LHS as first argument of RHS call.</p>
<pre><code class="lang-perl">"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
</code></pre>
<p>Zero runtime cost (parse-time desugaring). Binds looser than <code>||</code>, tighter than <code>?:</code>.</p>
</article>
<article class="doc-entry" id="doc-thread">
<h3><a class="doc-anchor" href="#doc-thread">#</a> <code>thread</code> / <code>~></code> (thread-first)</h3>
<p>Thread-first macro — chain stages where the threaded value is injected as the <strong>first</strong> argument (like Clojure's <code>-></code>).</p>
<pre><code class="lang-perl">~>1:10map{_*2}fi{_>5}sum p # 104 — ultra-concise
~> @data grep{_ > 5} map{_ * 2} sort{$_0 <=> $_1} |> join "," |> p
~> " hello " tm uc rv lc ufc sc cc kc tj p # short aliases
sub div { $_0 / $_1 }
~> 10 div(2) p # div(10, 2) = 5
~> 10 div(_, 2) p # explicit _ position: div(10, 2) = 5
</code></pre>
<p>Spellings: <code>~></code>, <code>thread</code>, <code>t</code>. Stages: bare function (<code>uc</code>, <code>tm</code>, …), function with block (<code>map{_ * 2}</code>, <code>grep{_ > 5}</code>), <code>name(args)</code> call where <code>_</code> (or <code>$_</code>) is the threaded-value placeholder, or <code>>{}</code> anonymous block. Bare <code>_</code> is equivalent to <code>$_</code> in any expression position. <code>|></code> terminates the macro.</p>
</article>
<article class="doc-entry" id="doc-thread-last">
<h3><a class="doc-anchor" href="#doc-thread-last">#</a> <code>~>></code> / <code>->></code> (thread-last)</h3>
<p>Thread-last macro — chain stages where the threaded value is injected as the <strong>last</strong> argument (like Clojure's <code>->></code>).</p>
<pre><code class="lang-perl">sub div { $_0 / $_1 }
~>> 10 div(2) p # div(2, 10) = 0.2
->> 10 div(_, 2) p # explicit _ position overrides: div(10, 2) = 5
# Thread-last is useful for list-consuming functions:
sub 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)
</code></pre>
<p>Spellings: <code>~>></code>, <code>->></code>. The explicit <code>_</code> (or <code>$_</code>) placeholder always takes precedence.</p>
</article>
<article class="doc-entry" id="doc-pipeline">
<h3><a class="doc-anchor" href="#doc-pipeline">#</a> <code>pipeline</code></h3>
<p><code>pipeline(@list)</code> — wrap a list (or iterator) in a lazy pipeline object supporting chained <code>->map</code>, <code>->filter</code>, <code>->take</code>, <code>->skip</code>, <code>->flat_map</code>, <code>->tap</code>, and other transforms that execute zero work until a terminal method is called.</p>
<p>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 <code>->collect</code> (materialize to list), <code>->reduce { ... }</code> (fold), <code>->for_each { ... }</code> (side-effect iteration), and <code>->count</code>. Pipelines compose naturally with stryke's <code>|></code> operator: you can feed <code>pipeline(...)</code> output into further <code>|></code> stages or vice versa. Use <code>pipeline</code> when you want explicit method-chaining style rather than the flat <code>|></code> pipe syntax — both compile to the same lazy evaluation engine.</p>
<pre><code class="lang-perl">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 }
</code></pre>
</article>
<article class="doc-entry" id="doc-par-pipeline">
<h3><a class="doc-anchor" href="#doc-par-pipeline">#</a> <code>par_pipeline</code></h3>
<p><code>par_pipeline(source => \@data, stages => [...], workers => N)</code> — build a multi-stage parallel pipeline where each stage's map/filter block runs concurrently across N worker threads.</p>
<p>Unlike <code>pmap</code> which parallelizes a single transform, <code>par_pipeline</code> 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 <code>workers</code> parameter defaults to the number of logical CPUs.</p>
<pre><code class="lang-perl">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,
)
</code></pre>
</article>
<article class="doc-entry" id="doc-par-pipeline-stream">
<h3><a class="doc-anchor" href="#doc-par-pipeline-stream">#</a> <code>par_pipeline_stream</code></h3>
<p><code>par_pipeline_stream(source => ..., stages => [...], workers => N)</code> — streaming variant of <code>par_pipeline</code> that connects stages via bounded <code>pchannel</code> queues instead of materializing intermediate arrays.</p>
<p>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 <code>ordered => 1</code> to reorder them to match input order at the cost of buffering.</p>
<pre><code class="lang-perl">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
)
</code></pre>
</article>
<article class="doc-entry" id="doc-collect">
<h3><a class="doc-anchor" href="#doc-collect">#</a> <code>collect</code></h3>
<p><code>collect ITERATOR</code> — materialize a lazy iterator or pipeline into a concrete list.</p>
<p>Pipeline stages in stryke are lazy: chaining <code>|> map {...} |> grep {...}</code> builds up a deferred computation without consuming any elements. Calling <code>collect</code> 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 <code>collect</code>, the iterator is consumed element-by-element by <code>e</code>, <code>take</code>, or other streaming sinks.</p>
<pre><code class="lang-perl">my @out = range(1,5) |> map { _ * 2 } |> collect
gen { yield $_ for 1..3 } |> collect |> e p
my @data = stdin |> grep /INFO/ |> collect
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-streaming-iterators">
<h2>Streaming Iterators</h2>
<p class="chapter-meta">24 topics</p>
<article class="doc-entry" id="doc-maps">
<h3><a class="doc-anchor" href="#doc-maps">#</a> <code>maps</code></h3>
<p><code>maps { BLOCK } LIST</code> — the lazy, streaming counterpart of <code>map</code>. Instead of materializing the entire output list, <code>maps</code> returns a pull iterator that evaluates the block on demand as downstream consumers request values. This makes it ideal for <code>|></code> pipeline chains, especially when combined with <code>take</code>, <code>greps</code>, or <code>collect</code>. Use <code>maps</code> over <code>map</code> when working with large ranges, infinite sequences, or when you want to short-circuit processing early with <code>take</code>. Memory usage is constant regardless of input size.</p>
<pre><code class="lang-perl">1..10 |> maps { _ * 3 } |> take 4 |> e p
# 3 6 9 12
1..1_000_000 |> maps { _ ** 2 } |> greps { _ > 100 } |> take 3 |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-greps">
<h3><a class="doc-anchor" href="#doc-greps">#</a> <code>greps</code></h3>
<p><code>greps { BLOCK } LIST</code> — the lazy, streaming counterpart of <code>grep</code>. Returns a pull iterator that only evaluates the predicate as elements are requested downstream. This is the preferred filtering function in <code>|></code> pipelines because it avoids materializing intermediate lists. Combine with <code>take</code> to short-circuit early, or with <code>maps</code> and <code>collect</code> for full lazy pipelines. The block receives <code>_</code> (or <code>$_</code>) just like <code>grep</code>.</p>
<pre><code class="lang-perl">1..100 |> greps { _ % 7 == 0 } |> take 3 |> e p
# 7 14 21
@lines |> greps { /ERROR/ } |> maps { tm } |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-filter">
<h3><a class="doc-anchor" href="#doc-filter">#</a> <code>filter</code></h3>
<p><code>filter</code> (alias <code>fi</code>) <code>{ BLOCK } LIST</code> — stryke-native lazy filter that returns a pull iterator, functionally identical to <code>greps</code> but named for familiarity with Rust/Ruby/JS conventions. Use <code>filter</code> or <code>greps</code> interchangeably in <code>|></code> chains; both are streaming and both set <code>_</code>/<code>$_</code> in the block. The result must be consumed with <code>collect</code>, <code>e p</code>, <code>foreach</code>, or another terminal. Prefer <code>filter</code> when writing stryke-idiomatic code; prefer <code>grep</code>/<code>greps</code> when porting from Perl.</p>
<pre><code class="lang-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
</code></pre>
</article>
<article class="doc-entry" id="doc-tap">
<h3><a class="doc-anchor" href="#doc-tap">#</a> <code>tap</code></h3>
<p><code>tap { BLOCK } LIST</code> — execute a side-effecting block for each element, then pass the element through unchanged.</p>
<p>The return value of the block is ignored; the original element is always forwarded to the next pipeline stage. This makes <code>tap</code> 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.</p>
<pre><code class="lang-perl">1..5 |> tap { log_debug "saw: $_" } |> map { _ * 2 } |> e p
@files |> tap { p "processing: $_" } |> map slurp |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-peek">
<h3><a class="doc-anchor" href="#doc-peek">#</a> <code>peek</code></h3>
<p><code>peek ITERATOR</code> — inspect the next element of an iterator without consuming it.</p>
<p>The peeked value is buffered internally so that the next call to <code>->next</code> or pipeline pull returns the same element. This is useful for lookahead parsing, conditional branching on the next value, or implementing <code>take_while</code>-style logic manually. Calling <code>peek</code> multiple times without advancing the iterator returns the same value each time. Works with any stryke iterator including <code>gen</code>, <code>range</code>, <code>stdin</code>, and pipeline results.</p>
<pre><code class="lang-perl">my $g = gen { yield $_ for 1..5 }
p peek $g # 1 (not consumed)
p $g->next # 1
p peek $g # 2
</code></pre>
</article>
<article class="doc-entry" id="doc-tee">
<h3><a class="doc-anchor" href="#doc-tee">#</a> <code>tee</code></h3>
<p><code>tee FILE, ITERATOR</code> — write each element to a file as a side effect while passing it through the pipeline.</p>
<p>Every element that flows through <code>tee</code> 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 <code>tee</code> command, useful for auditing or logging intermediate pipeline results to disk.</p>
<pre><code class="lang-perl">1..10 |> tee "/tmp/log.txt" |> map { _ * 2 } |> e p
stdin |> tee "/tmp/raw.log" |> grep /ERROR/ |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-take">
<h3><a class="doc-anchor" href="#doc-take">#</a> <code>take</code></h3>
<p><code>take N, LIST</code> / <code>head N, LIST</code> / <code>hd N, LIST</code> — return at most the first N elements.</p>
<p>In streaming mode, <code>take</code> 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 <code>range(1, 1_000_000) |> take 5</code> without allocating a million-element list. If the source has fewer than N elements, all of them are returned. The <code>head</code> and <code>hd</code> aliases mirror Unix <code>head</code> semantics.</p>
<pre><code class="lang-perl">1..100 |> take 5 |> e p # 1 2 3 4 5
my @top = hd 3, @sorted
stdin |> hd 10 |> e p # first 10 lines
</code></pre>
</article>
<article class="doc-entry" id="doc-tail">
<h3><a class="doc-anchor" href="#doc-tail">#</a> <code>tail</code></h3>
<p><code>tail N, @list</code> — returns the last N elements of the list. If N exceeds the list length, the entire list is returned. The alias <code>tl</code> is also available. This is the complement of <code>head</code>/<code>take</code> and mirrors Perl's <code>List::Util::tail</code>. In stryke, it works both as a function call and in <code>|></code> pipelines.</p>
<pre><code class="lang-perl">my @t = tail 2, 1..5
@t |> e p # 4 5
1..100 |> tl 3 |> e p # 98 99 100
</code></pre>
</article>
<article class="doc-entry" id="doc-drop">
<h3><a class="doc-anchor" href="#doc-drop">#</a> <code>drop</code></h3>
<p><code>drop N, LIST</code> / <code>skip N, LIST</code> / <code>drp N, LIST</code> — skip the first N elements and return the rest.</p>
<p>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 <code>skip</code> and <code>drp</code> aliases exist for readability in different contexts — all three compile to the same internal op.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-take-while">
<h3><a class="doc-anchor" href="#doc-take-while">#</a> <code>take_while</code></h3>
<p><code>take_while { COND } LIST</code> — emit leading elements while the predicate returns true, then stop.</p>
<p>The block receives each element as <code>$_</code>. 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 <code>take_while</code> efficient on infinite iterators and large streams. It is the complement of <code>drop_while</code>.</p>
<pre><code class="lang-perl">1..10 |> take_while { $_ < 5 } |> e p # 1 2 3 4
stdin |> take_while { !/^END/ } |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-drop-while">
<h3><a class="doc-anchor" href="#doc-drop-while">#</a> <code>drop_while</code></h3>
<p><code>drop_while { COND } LIST</code> — skip leading elements while the predicate returns true, then emit everything after.</p>
<p>The block receives each element as <code>$_</code>. 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.</p>
<pre><code class="lang-perl">1..10 |> drop_while { $_ < 5 } |> e p # 5 6 7 8 9 10
@log |> drop_while { /^ #/ } |> e p # skip comment header
</code></pre>
</article>
<article class="doc-entry" id="doc-reject">
<h3><a class="doc-anchor" href="#doc-reject">#</a> <code>reject</code></h3>
<p><code>reject { BLOCK } LIST</code> — stryke-native streaming inverse of <code>filter</code>/<code>greps</code>. It keeps only the elements for which the block returns false. This reads more naturally than <code>filter { !(...) }</code> when the condition describes what you want to exclude rather than what you want to keep. Like <code>filter</code> and <code>greps</code>, it returns a lazy iterator suitable for <code>|></code> chains. The block receives <code>$_</code> as the current element.</p>
<pre><code class="lang-perl">1..10 |> reject { $_ % 3 == 0 } |> e p
# 1 2 4 5 7 8 10
@files |> reject { /\.bak$/ } |> e p # skip backups
</code></pre>
</article>
<article class="doc-entry" id="doc-compact">
<h3><a class="doc-anchor" href="#doc-compact">#</a> <code>compact</code></h3>
<p><code>compact</code> (alias <code>cpt</code>) — stryke-native streaming operator that removes <code>undef</code> 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 <code>greps { defined($_) && $_ ne "" }</code> but more concise and faster because the check is inlined in Rust. Numeric zero and the string <code>"0"</code> are preserved since they are defined and non-empty.</p>
<pre><code class="lang-perl">my @raw = (1, undef, "", 2, undef, 3)
@raw |> compact |> e p # 1 2 3
split(/,/, "a,,b,,,c") |> cpt |> e p # a b c
</code></pre>
</article>
<article class="doc-entry" id="doc-concat">
<h3><a class="doc-anchor" href="#doc-concat">#</a> <code>concat</code></h3>
<p><code>concat</code> (alias <code>chain</code>) — 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.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-enumerate">
<h3><a class="doc-anchor" href="#doc-enumerate">#</a> <code>enumerate</code></h3>
<p><code>enumerate ITERATOR</code> / <code>en ITERATOR</code> — yield <code>[$index, $item]</code> pairs from a streaming iterator.</p>
<p>Each element is wrapped as <code>[$index, $item]</code> where the index starts at 0 and increments for each element. Unlike <code>with_index</code> which returns <code>[item, index]</code>, <code>enumerate</code> uses the Rust/Python convention of <code>[index, item]</code>. This is a streaming operation: the index counter is maintained lazily as elements flow through the pipeline.</p>
<pre><code class="lang-perl">stdin |> en |> e { p "$_->[0]: $_->[1]" }
1..5 |> en |> e { p "$_->[0]: $_->[1]" }
@lines |> en |> grep { $_->[0] < 10 } |> e { p $_->[1] }
</code></pre>
</article>
<article class="doc-entry" id="doc-chunk">
<h3><a class="doc-anchor" href="#doc-chunk">#</a> <code>chunk</code></h3>
<p><code>chunk N, ITERATOR</code> / <code>chk N, ITERATOR</code> — group elements into N-sized arrayrefs as they stream through.</p>
<p>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 <code>chunk</code> for batching work (e.g., bulk database inserts) or formatting output into rows.</p>
<pre><code class="lang-perl">1..9 |> chk 3 |> e { p join ",", @$_ }
# 1,2,3 4,5,6 7,8,9
stdin |> chk 100 |> e { bulk_insert(@$_) }
</code></pre>
</article>
<article class="doc-entry" id="doc-dedup">
<h3><a class="doc-anchor" href="#doc-dedup">#</a> <code>dedup</code></h3>
<p><code>dedup ITERATOR</code> / <code>dup ITERATOR</code> — drop consecutive duplicate elements from a stream.</p>
<p>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 <code>distinct</code> instead.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-distinct">
<h3><a class="doc-anchor" href="#doc-distinct">#</a> <code>distinct</code></h3>
<p><code>distinct LIST</code> — remove duplicate elements, preserving first-occurrence order (alias for <code>uniq</code>).</p>
<p>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 <code>distinct</code> 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.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-flatten">
<h3><a class="doc-anchor" href="#doc-flatten">#</a> <code>flatten</code></h3>
<p><code>flatten LIST</code> / <code>fl LIST</code> — recursively flatten nested arrayrefs into a single flat list.</p>
<p>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 (<code>|> fl</code>) it streams element-by-element, so you can chain it with <code>map</code>, <code>grep</code>, or <code>take</code> without materializing the entire intermediate list. The <code>fl</code> alias keeps pipeline chains concise.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-with-index">
<h3><a class="doc-anchor" href="#doc-with-index">#</a> <code>with_index</code></h3>
<p><code>with_index LIST</code> / <code>wi LIST</code> — pair each element with its 0-based index as <code>[$item, $index]</code>.</p>
<p>Each element is wrapped in a two-element arrayref where <code>$_->[0]</code> is the original value and <code>$_->[1]</code> 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 <code>[item, index]</code>, which differs from <code>enumerate</code> which yields <code>[index, item]</code>.</p>
<pre><code class="lang-perl">qw(a b c) |> wi |> e { p "$_->[1]: $_->[0]" }
# 0: a 1: b 2: c
@data |> wi |> grep { $_->[1] % 2 == 0 } |> e { p $_->[0] }
</code></pre>
</article>
<article class="doc-entry" id="doc-first-or">
<h3><a class="doc-anchor" href="#doc-first-or">#</a> <code>first_or</code></h3>
<p><code>first_or DEFAULT, LIST</code> — return the first element of the list, or DEFAULT if the list is empty.</p>
<p>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 <code>grep</code> or <code>map</code> pipeline where you need a safe fallback instead of <code>undef</code> when no match is found.</p>
<pre><code class="lang-perl">my $v = first_or 0, @maybe_empty
my $x = grep { $_ > 99 } @nums |> first_or -1
stdin |> grep /^ERROR/ |> first_or "(none)" |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-range">
<h3><a class="doc-anchor" href="#doc-range">#</a> <code>range</code></h3>
<p><code>range(START, END [, STEP])</code> — create a lazy integer iterator from START to END with an optional step.</p>
<p>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 <code>range(1, 1_000_000)</code> as cheap to create as <code>range(1, 5)</code>. Combine with <code>|></code> to feed into streaming pipelines.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-stdin">
<h3><a class="doc-anchor" href="#doc-stdin">#</a> <code>stdin</code></h3>
<p><code>stdin</code> — return a streaming iterator over lines read from standard input.</p>
<p>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 <code>stdin</code> with <code>take</code>, <code>grep</code>, or <code>first_or</code> 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.</p>
<pre><code class="lang-perl">stdin |> grep /error/i |> e p
stdin |> take 5 |> e p
stdin |> en |> e { p "$_->[0]: $_->[1]" }
</code></pre>
</article>
<article class="doc-entry" id="doc-nth">
<h3><a class="doc-anchor" href="#doc-nth">#</a> <code>nth</code></h3>
<p><code>nth N, LIST</code> — return the Nth element using 0-based indexing.</p>
<p>When used in a pipeline, <code>nth</code> 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 <code>$list[N]</code> but works as a function call for pipeline composition. Returns <code>undef</code> if the list has fewer than N+1 elements.</p>
<pre><code class="lang-perl">my $third = nth 2, @data
1..10 |> nth 4 |> p # 5
stdin |> nth 0 |> p # first line
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-list-operations">
<h2>List Operations</h2>
<p class="chapter-meta">62 topics</p>
<article class="doc-entry" id="doc-map">
<h3><a class="doc-anchor" href="#doc-map">#</a> <code>map</code></h3>
<p><code>map BLOCK LIST</code> — evaluates the block for each element of the list, setting <code>$_</code> 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 <code>map</code> when you need the full result array or when the input is small. For large or infinite sequences, prefer <code>maps</code> (the streaming variant). The block can return zero, one, or multiple values per element, making <code>map</code> useful for both transformation and flattening. Use <code>{ |$var| body }</code> to name the block parameter instead of <code>$_</code>.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-grep">
<h3><a class="doc-anchor" href="#doc-grep">#</a> <code>grep</code></h3>
<p><code>grep { BLOCK } LIST</code> — filters the list, returning only elements for which the block evaluates to true. The current element is available as <code>$_</code>. 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 <code>grep</code>. For streaming/lazy filtering in <code>|></code> pipelines, use <code>greps</code> or <code>filter</code> instead. Use <code>{ |$var| body }</code> to name the block parameter instead of <code>$_</code>.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-sort">
<h3><a class="doc-anchor" href="#doc-sort">#</a> <code>sort</code></h3>
<p><code>sort [BLOCK] LIST</code> — returns a new list sorted in ascending order. Without a block, <code>sort</code> compares elements as strings (lexicographic). Pass a comparator block using <code>$_0</code> and <code>$_1</code> (stryke style) or <code>$a</code> and <code>$b</code> (classic Perl) to control ordering: use <code><=></code> for numeric and <code>cmp</code> 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 <code>{ |$x, $y| body }</code> to name the two comparator params. Works naturally in <code>|></code> pipelines.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-reverse">
<h3><a class="doc-anchor" href="#doc-reverse">#</a> <code>reverse</code></h3>
<p><code>reverse LIST</code> — in list context, return the elements in reverse order; in scalar context, reverse the characters of a string.</p>
<p>The dual nature of <code>reverse</code> is context-dependent: <code>reverse @array</code> flips element order, while <code>scalar reverse $string</code> (or just <code>reverse $string</code> in scalar context) reverses character order. In stryke, the string form is Unicode-aware, correctly reversing multi-byte characters rather than individual bytes. In <code>|></code> pipelines, use the <code>t rev</code> shorthand for a concise streaming string reverse. <code>reverse</code> does not modify the original — it always returns a new list or string.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-reduce">
<h3><a class="doc-anchor" href="#doc-reduce">#</a> <code>reduce</code></h3>
<p><code>reduce { $_0 OP $_1 } @list</code> — performs a sequential left fold over the list. The first two elements are passed as <code>$_0</code> and <code>$_1</code> to the block; the result becomes <code>$_0</code> for the next iteration. The traditional <code>$a</code>/<code>$b</code> names are also supported for Perl compatibility. Use <code>{ |$acc, $val| body }</code> to name the two params. Returns <code>undef</code> for an empty list and the single element for a one-element list. For a fold with an explicit initial value, see <code>fold</code>.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-fold">
<h3><a class="doc-anchor" href="#doc-fold">#</a> <code>fold</code></h3>
<p><code>fold { $_0 OP $_1 } INIT, @list</code> — left fold with an explicit initial accumulator value. The initial value is passed as the first <code>$_0</code>, and each list element arrives as <code>$_1</code>. Unlike <code>reduce</code>, <code>fold</code> never returns <code>undef</code> for an empty list — it returns the initial value instead. Both <code>$a</code>/<code>$b</code> and <code>$_0</code>/<code>$_1</code> are supported in the block. Use <code>fold</code> when you need a guaranteed starting point for the accumulation.</p>
<pre><code class="lang-perl">my $total = fold { $_0 + $_1 } 100, 1..5
p $total # 115
my $csv = fold { "$_0,$_1" } "", @fields
</code></pre>
</article>
<article class="doc-entry" id="doc-reductions">
<h3><a class="doc-anchor" href="#doc-reductions">#</a> <code>reductions</code></h3>
<p><code>reductions { $_0 OP $_1 } @list</code> — 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 <code>$_0</code>/<code>$_1</code> and <code>$a</code>/<code>$b</code> naming conventions are supported.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-all">
<h3><a class="doc-anchor" href="#doc-all">#</a> <code>all</code></h3>
<p><code>all { COND } @list</code> — returns true (1) if every element in the list satisfies the predicate, false ("") otherwise. The block receives each element as <code>$_</code> and should return a boolean. Short-circuits on the first failing element, so it never evaluates more than necessary. Works with <code>|></code> pipelines and accepts bare lists or array variables.</p>
<pre><code class="lang-perl">my @nums = 2, 4, 6, 8
p all { $_ % 2 == 0 } @nums # 1
1..100 |> all { $_ > 0 } |> p # 1
</code></pre>
</article>
<article class="doc-entry" id="doc-any">
<h3><a class="doc-anchor" href="#doc-any">#</a> <code>any</code></h3>
<p><code>any { COND } @list</code> — returns true (1) if at least one element satisfies the predicate, false ("") if none do. The block receives each element as <code>$_</code>. Short-circuits on the first match, making it efficient even on large lists. This is the stryke equivalent of Perl's <code>List::Util::any</code> and can be used in <code>|></code> pipelines.</p>
<pre><code class="lang-perl">my @vals = 1, 3, 5, 8
p any { $_ > 7 } @vals # 1
1..1000 |> any { $_ == 42 } |> p # 1
</code></pre>
</article>
<article class="doc-entry" id="doc-none">
<h3><a class="doc-anchor" href="#doc-none">#</a> <code>none</code></h3>
<p><code>none { COND } @list</code> — returns true (1) if no element satisfies the predicate, false ("") if any element matches. Logically equivalent to <code>!any { COND } @list</code> 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.</p>
<pre><code class="lang-perl">my @words = ("cat", "dog", "bird")
p none { /z/ } @words # 1
p "all non-negative" if none { $_ < 0 } @vals
</code></pre>
</article>
<article class="doc-entry" id="doc-first">
<h3><a class="doc-anchor" href="#doc-first">#</a> <code>first</code></h3>
<p><code>first { COND } @list</code> — returns the first element for which the block returns true, or <code>undef</code> if no element matches. The alias <code>fst</code> 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.</p>
<pre><code class="lang-perl">my $f = first { $_ > 10 } 3, 7, 12, 20
p $f # 12
1..1_000_000 |> first { $_ % 9999 == 0 } |> p # 9999
</code></pre>
</article>
<article class="doc-entry" id="doc-min">
<h3><a class="doc-anchor" href="#doc-min">#</a> <code>min</code></h3>
<p><code>min @list</code> — returns the numerically smallest value from a list. Compares all elements using numeric (<code><=></code>) comparison, so stringy values are coerced to numbers. Returns <code>undef</code> for an empty list. In stryke, <code>min</code> is a built-in that does not require <code>use List::Util</code> and works directly in <code>|></code> pipelines.</p>
<pre><code class="lang-perl">p min(5, 3, 9, 1) # 1
my @temps = (72.1, 68.5, 74.3)
@temps |> min |> p # 68.5
</code></pre>
</article>
<article class="doc-entry" id="doc-max">
<h3><a class="doc-anchor" href="#doc-max">#</a> <code>max</code></h3>
<p><code>max @list</code> — returns the numerically largest value from a list. Compares all elements using numeric (<code><=></code>) comparison. Returns <code>undef</code> for an empty list. Like <code>min</code>, this is a stryke built-in available without imports and works in <code>|></code> pipelines. Combine with <code>map</code> to extract max values from complex structures.</p>
<pre><code class="lang-perl">p max(5, 3, 9, 1) # 9
1..100 |> map { $_ ** 2 } |> max |> p # 10000
</code></pre>
</article>
<article class="doc-entry" id="doc-sum">
<h3><a class="doc-anchor" href="#doc-sum">#</a> <code>sum</code></h3>
<p><code>sum @list</code> returns the numeric sum of all elements. Returns <code>undef</code> for an empty list. <code>sum0</code> is identical except it returns <code>0</code> for an empty list, which avoids the need for a fallback <code>// 0</code> guard. Both are stryke built-ins that work in <code>|></code> pipelines. Use <code>sum0</code> in contexts where an empty input is expected and you need a safe numeric default.</p>
<pre><code class="lang-perl">p sum(1..100) # 5050
p sum0() # 0
@prices |> map { $_->{amount} } |> sum0 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-product">
<h3><a class="doc-anchor" href="#doc-product">#</a> <code>product</code></h3>
<p><code>product @list</code> — returns the product of all numeric elements in the list. Returns <code>undef</code> for an empty list. Useful for computing factorials, combinatoric products, and compound multipliers. In stryke this is a built-in that composes naturally with <code>|></code> pipelines and <code>range</code>.</p>
<pre><code class="lang-perl">p product(1..5) # 120
range(1, 10) |> product |> p # 3628800
</code></pre>
</article>
<article class="doc-entry" id="doc-mean">
<h3><a class="doc-anchor" href="#doc-mean">#</a> <code>mean</code></h3>
<p><code>mean @list</code> — returns the arithmetic mean (average) of a numeric list. Computed as <code>sum / count</code> in a single pass. Returns <code>undef</code> for an empty list. The result is always a floating-point value even if all inputs are integers. Combine with <code>map</code> to compute averages over extracted fields.</p>
<pre><code class="lang-perl">p mean(2, 4, 6, 8) # 5
@students |> map { $_->{score} } |> mean |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-median">
<h3><a class="doc-anchor" href="#doc-median">#</a> <code>median</code></h3>
<p><code>median @list</code> — 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 <code>undef</code> for an empty list.</p>
<pre><code class="lang-perl">p median(1, 3, 5, 7, 9) # 5
p median(1, 3, 5, 7) # 4
1..100 |> median |> p # 50.5
</code></pre>
</article>
<article class="doc-entry" id="doc-mode">
<h3><a class="doc-anchor" href="#doc-mode">#</a> <code>mode</code></h3>
<p><code>mode @list</code> — returns the most frequently occurring value in the list. If there is a tie, the value that appears first in the list wins. Returns <code>undef</code> 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>
<pre><code class="lang-perl">p mode(1, 2, 2, 3, 3, 3) # 3
my @logs = qw(INFO WARN INFO ERROR INFO)
p mode(@logs) # INFO
</code></pre>
</article>
<article class="doc-entry" id="doc-stddev">
<h3><a class="doc-anchor" href="#doc-stddev">#</a> <code>stddev</code></h3>
<p><code>stddev @list</code> (alias <code>std</code>) — 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 <code>undef</code> for an empty list.</p>
<pre><code class="lang-perl">p stddev(2, 4, 4, 4, 5, 5, 7, 9) # 2
1..10 |> std |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-variance">
<h3><a class="doc-anchor" href="#doc-variance">#</a> <code>variance</code></h3>
<p><code>variance @list</code> — returns the population variance of a numeric list, computed as the mean of the squared deviations from the mean. Like <code>stddev</code>, this uses N (not N-1) as the divisor. The variance is <code>stddev ** 2</code>. Returns <code>undef</code> for an empty list. Useful for statistical analysis and as a building block for higher-order stats.</p>
<pre><code class="lang-perl">p variance(2, 4, 4, 4, 5, 5, 7, 9) # 4
my @samples = map { rand(100) } 1..1000
p variance(@samples)
</code></pre>
</article>
<article class="doc-entry" id="doc-sample">
<h3><a class="doc-anchor" href="#doc-sample">#</a> <code>sample</code></h3>
<p><code>sample N, @list</code> — 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.</p>
<pre><code class="lang-perl">my @pick = sample 3, 1..100
@pick |> e p # 3 random values
my @test_cases = sample 10, @all_cases
</code></pre>
</article>
<article class="doc-entry" id="doc-shuffle">
<h3><a class="doc-anchor" href="#doc-shuffle">#</a> <code>shuffle</code></h3>
<p><code>shuffle @list</code> — 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 <code>use List::Util</code> is needed. The alias <code>shuf</code> is also available. Commonly used with <code>|></code> and <code>take</code> to draw random subsets.</p>
<pre><code class="lang-perl">my @deck = shuffle 1..52
@deck |> take 5 |> e p # 5 random cards
my @randomized = shuffle @questions
</code></pre>
</article>
<article class="doc-entry" id="doc-uniq">
<h3><a class="doc-anchor" href="#doc-uniq">#</a> <code>uniq</code></h3>
<p><code>uniq @list</code> — removes duplicate elements from a list, preserving the order of first occurrence. Comparison is done by string equality. The alias <code>uq</code> is also available. This is eager (not streaming) and returns a new list. For streaming deduplication in <code>|></code> pipelines, use <code>distinct</code>. For type-specific comparison, see <code>uniqnum</code>, <code>uniqstr</code>, and <code>uniqint</code>.</p>
<pre><code class="lang-perl">my @u = uniq 1, 2, 2, 3, 1, 3
@u |> e p # 1 2 3
my @hosts = uniq @all_hosts
</code></pre>
</article>
<article class="doc-entry" id="doc-uniqint">
<h3><a class="doc-anchor" href="#doc-uniqint">#</a> <code>uniqint</code></h3>
<p><code>uniqint @list</code> — removes duplicate elements comparing values as integers. Each element is truncated to its integer part before comparison, so <code>1.1</code> and <code>1.9</code> are considered equal (both become <code>1</code>). The first occurrence is kept. This is useful when you have floating-point data but care only about the integer portion for uniqueness.</p>
<pre><code class="lang-perl">my @u = uniqint 1, 1.1, 1.9, 2
@u |> e p # 1 2
my @distinct_ids = uniqint @raw_ids
</code></pre>
</article>
<article class="doc-entry" id="doc-uniqnum">
<h3><a class="doc-anchor" href="#doc-uniqnum">#</a> <code>uniqnum</code></h3>
<p><code>uniqnum @list</code> — removes duplicate elements comparing values as floating-point numbers. Unlike <code>uniq</code> (which compares as strings), <code>uniqnum</code> treats <code>1.0</code> and <code>1.00</code> 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.</p>
<pre><code class="lang-perl">my @u = uniqnum 1.0, 1.00, 2.5, 2.50
@u |> e p # 1 2.5
my @prices = uniqnum @all_prices
</code></pre>
</article>
<article class="doc-entry" id="doc-uniqstr">
<h3><a class="doc-anchor" href="#doc-uniqstr">#</a> <code>uniqstr</code></h3>
<p><code>uniqstr @list</code> — removes duplicate elements comparing values strictly as strings. This is the same comparison as <code>uniq</code> but makes the intent explicit. Numeric values <code>1</code> and <code>1.0</code> are considered different because their string representations differ. Use <code>uniqstr</code> when you want to be explicit that string semantics are intended.</p>
<pre><code class="lang-perl">my @u = uniqstr "a", "b", "a", "c"
@u |> e p # a b c
my @tags = uniqstr @all_tags
</code></pre>
</article>
<article class="doc-entry" id="doc-zip">
<h3><a class="doc-anchor" href="#doc-zip">#</a> <code>zip</code></h3>
<p><code>zip(\@a, \@b, ...)</code> — 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 <code>zp</code> is also available. By default, <code>zip</code> pads shorter arrays with <code>undef</code> (equivalent to <code>zip_longest</code>). For truncating behavior, use <code>zip_shortest</code>.</p>
<pre><code class="lang-perl">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)
</code></pre>
</article>
<article class="doc-entry" id="doc-zip-longest">
<h3><a class="doc-anchor" href="#doc-zip-longest">#</a> <code>zip_longest</code></h3>
<p><code>zip_longest(\@a, \@b, ...)</code> — combines arrays element-wise, padding shorter arrays with <code>undef</code> to match the longest. This is the explicit version of the default <code>zip</code> behavior. Every input array contributes exactly one element per output tuple; missing elements become <code>undef</code>. Useful when you need to process all data from unequal-length sources.</p>
<pre><code class="lang-perl">my @a = 1..3
my @b = ("x")
zip_longest(\@a, \@b) |> e p # [1,x] [2,undef] [3,undef]
</code></pre>
</article>
<article class="doc-entry" id="doc-zip-shortest">
<h3><a class="doc-anchor" href="#doc-zip-shortest">#</a> <code>zip_shortest</code></h3>
<p><code>zip_shortest(\@a, \@b, ...)</code> — combines arrays element-wise, stopping at the shortest input array. No <code>undef</code> 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.</p>
<pre><code class="lang-perl">my @a = 1..5
my @b = ("x","y")
zip_shortest(\@a, \@b) |> e p # [1,x] [2,y]
my @paired = zip_shortest(\@keys, \@values)
</code></pre>
</article>
<article class="doc-entry" id="doc-chunked">
<h3><a class="doc-anchor" href="#doc-chunked">#</a> <code>chunked</code></h3>
<p><code>chunked N, @list</code> — 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 <code>chk</code> is also available. In stryke, <code>chunked</code> is eager and returns a list of arrayrefs; for streaming chunk behavior in pipelines, use <code>chunk</code>.</p>
<pre><code class="lang-perl">my @ch = chunked 3, 1..7
@ch |> e p # [1,2,3] [4,5,6] [7]
1..12 |> chunked 4 |> e { p join ",", @$_ }
</code></pre>
</article>
<article class="doc-entry" id="doc-windowed">
<h3><a class="doc-anchor" href="#doc-windowed">#</a> <code>windowed</code></h3>
<p><code>windowed N, @list</code> — returns a sliding window of N consecutive elements over the list. Each window is an arrayref. The output contains <code>len - N + 1</code> windows. Unlike <code>chunked</code>, windows overlap: each successive window advances by one element. The alias <code>win</code> is also available. Useful for computing moving averages, detecting patterns in sequences, or n-gram extraction.</p>
<pre><code class="lang-perl">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] }
</code></pre>
</article>
<article class="doc-entry" id="doc-pairs">
<h3><a class="doc-anchor" href="#doc-pairs">#</a> <code>pairs</code></h3>
<p><code>pairs @list</code> — takes a flat list and groups consecutive elements into pairs, returning a list of two-element arrayrefs <code>([$k, $v], ...)</code>. The input list must have an even number of elements. Each pair can be accessed via array indexing (<code>$_->[0]</code>, <code>$_->[1]</code>). This is the inverse of <code>unpairs</code> and is commonly used to iterate over hash-like flat lists in a structured way.</p>
<pre><code class="lang-perl">my @p = pairs "a", 1, "b", 2
@p |> e { p "$_->[0]=$_->[1]" } # a=1 b=2
my @entries = pairs %hash
</code></pre>
</article>
<article class="doc-entry" id="doc-unpairs">
<h3><a class="doc-anchor" href="#doc-unpairs">#</a> <code>unpairs</code></h3>
<p><code>unpairs @list_of_pairs</code> — flattens a list of two-element arrayrefs back into a flat key-value list. This is the inverse of <code>pairs</code>. Each arrayref <code>[$k, $v]</code> 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.</p>
<pre><code class="lang-perl">my @flat = unpairs ["a",1], ["b",2]
@flat |> e p # a 1 b 2
my %h = unpairs @filtered_pairs
</code></pre>
</article>
<article class="doc-entry" id="doc-pairkeys">
<h3><a class="doc-anchor" href="#doc-pairkeys">#</a> <code>pairkeys</code></h3>
<p><code>pairkeys @list</code> — extracts the keys (even-indexed elements) from a flat pairlist. Given a list like <code>("a", 1, "b", 2, "c", 3)</code>, returns <code>("a", "b", "c")</code>. This is equivalent to <code>map { $_->[0] } pairs @list</code> but more concise and efficient. Useful for extracting just the key side of a key-value flat list without constructing intermediate pair objects.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-pairvalues">
<h3><a class="doc-anchor" href="#doc-pairvalues">#</a> <code>pairvalues</code></h3>
<p><code>pairvalues @list</code> — extracts the values (odd-indexed elements) from a flat pairlist. Given <code>("a", 1, "b", 2)</code>, returns <code>(1, 2)</code>. This is equivalent to <code>map { $_->[1] } pairs @list</code> but more concise. Pair it with <code>pairkeys</code> to split a flat key-value list into separate key and value arrays.</p>
<pre><code class="lang-perl">my @v = pairvalues "a", 1, "b", 2
@v |> e p # 1 2
my @defaults = (timeout => 30, retries => 3)
my @settings = pairvalues @defaults
</code></pre>
</article>
<article class="doc-entry" id="doc-pairmap">
<h3><a class="doc-anchor" href="#doc-pairmap">#</a> <code>pairmap</code></h3>
<p><code>pairmap BLOCK @list</code> — maps over consecutive pairs in a flat list, passing the key as <code>$_0</code> (or <code>$a</code>) and the value as <code>$_1</code> (or <code>$b</code>). The block can return any number of elements. This is the pair-aware equivalent of <code>map</code> and is ideal for transforming hash-like flat lists. The result is a flat list of whatever the block returns.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-pairgrep">
<h3><a class="doc-anchor" href="#doc-pairgrep">#</a> <code>pairgrep</code></h3>
<p><code>pairgrep { BLOCK } @list</code> — filters consecutive pairs from a flat list, keeping only those where the block returns true. The key is available as <code>$_0</code> (or <code>$a</code>) and the value as <code>$_1</code> (or <code>$b</code>). Returns a flat list of the matching key-value pairs. This is the pair-aware equivalent of <code>grep</code> and is useful for filtering hash-like data by both key and value simultaneously.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-pairfirst">
<h3><a class="doc-anchor" href="#doc-pairfirst">#</a> <code>pairfirst</code></h3>
<p><code>pairfirst { BLOCK } @list</code> — returns the first pair from a flat list where the block returns true, as a two-element list <code>($key, $value)</code>. The key is <code>$_0</code> (or <code>$a</code>) and the value is <code>$_1</code> (or <code>$b</code>). Short-circuits on the first match. Returns an empty list if no pair matches. This is the pair-aware equivalent of <code>first</code>.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-mesh">
<h3><a class="doc-anchor" href="#doc-mesh">#</a> <code>mesh</code></h3>
<p><code>mesh(\@a, \@b, ...)</code> — interleaves multiple arrays into a flat list rather than arrayrefs. While <code>zip</code> returns <code>([1,"a"], [2,"b"])</code>, <code>mesh</code> returns <code>(1, "a", 2, "b")</code>. This makes it ideal for constructing hashes from parallel key and value arrays. The result is a flat list suitable for direct hash assignment.</p>
<pre><code class="lang-perl">my @k = ("a","b")
my @v = (1,2)
my %h = mesh(\@k, \@v)
p $h{a} # 1
my %lookup = mesh(\@ids, \@names)
</code></pre>
</article>
<article class="doc-entry" id="doc-mesh-longest">
<h3><a class="doc-anchor" href="#doc-mesh-longest">#</a> <code>mesh_longest</code></h3>
<p><code>mesh_longest(\@a, \@b, ...)</code> — interleaves arrays into a flat list, padding shorter arrays with <code>undef</code> to match the longest. Like <code>mesh</code>, the output is flat (not arrayrefs). Missing elements become <code>undef</code> in the output sequence. Use this when building a flat interleaved list from arrays of unequal length where you need every element represented.</p>
<pre><code class="lang-perl">my @a = 1..3
my @b = ("x")
my @r = mesh_longest(\@a, \@b)
@r |> e p # 1 x 2 undef 3 undef
</code></pre>
</article>
<article class="doc-entry" id="doc-mesh-shortest">
<h3><a class="doc-anchor" href="#doc-mesh-shortest">#</a> <code>mesh_shortest</code></h3>
<p><code>mesh_shortest(\@a, \@b, ...)</code> — interleaves arrays into a flat list, stopping at the shortest input array. No <code>undef</code> 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.</p>
<pre><code class="lang-perl">my @a = 1..3
my @b = ("x","y")
my @r = mesh_shortest(\@a, \@b)
@r |> e p # 1 x 2 y
</code></pre>
</article>
<article class="doc-entry" id="doc-partition">
<h3><a class="doc-anchor" href="#doc-partition">#</a> <code>partition</code></h3>
<p><code>partition</code> — pipeline / string helpers builtin. Alias for <code>drop</code>.</p>
<pre><code class="lang-perl">my $result = partition $x
# or in a pipeline:
@list |> map partition |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-frequencies">
<h3><a class="doc-anchor" href="#doc-frequencies">#</a> <code>frequencies</code></h3>
<p><code>frequencies</code> (aliases <code>freq</code>, <code>frq</code>) 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 <code>dd</code> for inspection or <code>to_json</code> for serialization.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-tally">
<h3><a class="doc-anchor" href="#doc-tally">#</a> <code>tally</code></h3>
<p><code>tally</code> 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 <code>Enumerable#tally</code> or Python's <code>Counter</code>. Similar to <code>frequencies</code> but follows the Ruby naming convention.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-interleave">
<h3><a class="doc-anchor" href="#doc-interleave">#</a> <code>interleave</code></h3>
<p><code>interleave</code> (alias <code>il</code>) 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 <code>undef</code> 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.</p>
<pre><code class="lang-perl">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]
</code></pre>
</article>
<article class="doc-entry" id="doc-pluck">
<h3><a class="doc-anchor" href="#doc-pluck">#</a> <code>pluck</code></h3>
<p><code>pluck KEY, LIST_OF_HASHREFS</code> — extract a single key from each hashref in the list.</p>
<p>For each element, <code>pluck</code> dereferences it as a hashref and returns the value at the given key. Elements where the key is missing yield <code>undef</code>. 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 <code>map { $_->{KEY} }</code> but more readable and optimized internally.</p>
<pre><code class="lang-perl">@users |> pluck "name" |> e p
my @ids = pluck "id", @records
@rows |> pluck "email" |> distinct |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-grep-v">
<h3><a class="doc-anchor" href="#doc-grep-v">#</a> <code>grep_v</code></h3>
<p><code>grep_v PATTERN, LIST</code> — inverse grep: reject elements that match the pattern, keep the rest.</p>
<p>This is the complement of <code>grep</code> — 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 <code>grep { !/pattern/ }</code> double-negation.</p>
<pre><code class="lang-perl">@words |> grep_v /^ #/ |> e p # drop comments
my @clean = grep_v qr/tmp/, @files
stdin |> grep_v /^\s*$/ |> e p # drop blank lines
</code></pre>
</article>
<article class="doc-entry" id="doc-select-keys">
<h3><a class="doc-anchor" href="#doc-select-keys">#</a> <code>select_keys</code></h3>
<p><code>select_keys</code> — pipeline / string helpers builtin.</p>
<pre><code class="lang-perl">my $result = select_keys $x
# or in a pipeline:
@list |> map select_keys |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-clamp">
<h3><a class="doc-anchor" href="#doc-clamp">#</a> <code>clamp</code></h3>
<p><code>clamp</code> (alias <code>clp</code>) 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.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-normalize">
<h3><a class="doc-anchor" href="#doc-normalize">#</a> <code>normalize</code></h3>
<p><code>normalize</code> (alias <code>nrm</code>) 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.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-compose">
<h3><a class="doc-anchor" href="#doc-compose">#</a> <code>compose</code></h3>
<p><code>compose</code> (alias <code>comp</code>) creates a right-to-left function composition. Given <code>compose(\&f, \&g)</code>, calling the result with <code>x</code> computes <code>f(g(x))</code>. 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.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-partial">
<h3><a class="doc-anchor" href="#doc-partial">#</a> <code>partial</code></h3>
<p><code>partial</code> returns a partially applied function — the bound arguments are prepended to any arguments supplied at call time. <code>partial(\&f, @bound)->(x)</code> is equivalent to <code>f(@bound, x)</code>. This is the standard partial application from functional programming, useful for creating specialized versions of general functions without closures.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-curry">
<h3><a class="doc-anchor" href="#doc-curry">#</a> <code>curry</code></h3>
<p><code>curry</code> 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. <code>curry(\&f, N)->(a)->(b)</code> calls <code>f(a, b)</code> when N=2. If all arguments are supplied at once, it calls immediately.</p>
<pre><code class="lang-perl">my $add = curry(fn { $_[0] + $_[1] }, 2)
my $add5 = $add->(5)
p $add5->(3) # 8
p $add->(10, 20) # 30 (enough args — calls immediately)
</code></pre>
</article>
<article class="doc-entry" id="doc-memoize">
<h3><a class="doc-anchor" href="#doc-memoize">#</a> <code>memoize</code></h3>
<p><code>memoize</code> (alias <code>memo</code>) 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.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-once">
<h3><a class="doc-anchor" href="#doc-once">#</a> <code>once</code></h3>
<p><code>once</code> 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.</p>
<pre><code class="lang-perl">my $init = once(fn { p "initializing..."
42 })
p $init->() # prints "initializing..." → 42
p $init->() # 42 (no print — cached)
p $init->() # 42 (still cached)
</code></pre>
</article>
<article class="doc-entry" id="doc-constantly">
<h3><a class="doc-anchor" href="#doc-constantly">#</a> <code>constantly</code></h3>
<p><code>constantly</code> (alias <code>const</code>) 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.</p>
<pre><code class="lang-perl">my $zero = constantly(0)
p $zero->("anything") # 0
my @defaults = map { constantly(0)->() } 1..5 # [0,0,0,0,0]
</code></pre>
</article>
<article class="doc-entry" id="doc-complement">
<h3><a class="doc-anchor" href="#doc-complement">#</a> <code>complement</code></h3>
<p><code>complement</code> (alias <code>compl</code>) wraps a predicate function and returns a new function that negates its boolean result. <code>complement(\&even?)->(3)</code> returns true. This is the functional equivalent of <code>!f(x)</code> without creating a closure.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-juxt">
<h3><a class="doc-anchor" href="#doc-juxt">#</a> <code>juxt</code></h3>
<p><code>juxt</code> (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.</p>
<pre><code class="lang-perl">my $stats = juxt(fn { min @_ }, fn { max @_ }, fn { avg @_ })
my @r = $stats->(3, 1, 4, 1, 5)
p "@r" # 1 5 2.8
</code></pre>
</article>
<article class="doc-entry" id="doc-fnil">
<h3><a class="doc-anchor" href="#doc-fnil">#</a> <code>fnil</code></h3>
<p><code>fnil</code> wraps a function so that any <code>undef</code> arguments are replaced with the given defaults before the function is called. This eliminates repetitive <code>// $default</code> patterns inside function bodies.</p>
<pre><code class="lang-perl">my $greet = fnil(fn { "Hello, $_[0]!" }, "World")
p $greet->(undef) # Hello, World!
p $greet->("Alice") # Hello, Alice!
</code></pre>
</article>
<article class="doc-entry" id="doc-deep-clone">
<h3><a class="doc-anchor" href="#doc-deep-clone">#</a> <code>deep_clone</code></h3>
<p><code>deep_clone</code> (alias <code>dclone</code>) 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 <code>structuredClone</code> or Perl's <code>Storable::dclone</code>.</p>
<pre><code class="lang-perl">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)
</code></pre>
</article>
<article class="doc-entry" id="doc-deep-merge">
<h3><a class="doc-anchor" href="#doc-deep-merge">#</a> <code>deep_merge</code></h3>
<p><code>deep_merge</code> (alias <code>dmerge</code>) 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 <code>deep_merge</code>, and config-file overlay patterns. Returns a new hash ref — neither input is modified.</p>
<pre><code class="lang-perl">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)
</code></pre>
</article>
<article class="doc-entry" id="doc-deep-equal">
<h3><a class="doc-anchor" href="#doc-deep-equal">#</a> <code>deep_equal</code></h3>
<p><code>deep_equal</code> (alias <code>deq</code>) 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 <code>assert.deepStrictEqual</code>, Lodash <code>isEqual</code>, or Python's <code>==</code> on nested dicts/lists.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-stryke-extensions">
<h2>stryke Extensions</h2>
<p class="chapter-meta">19 topics</p>
<article class="doc-entry" id="doc-fn">
<h3><a class="doc-anchor" href="#doc-fn">#</a> <code>fn</code></h3>
<p>Alias for <code>sub</code> — define a function with optional typed parameters and default values.</p>
<pre><code class="lang-perl">fn double($x) { $x * 2 }
my $f = fn { $_ * 2 }
my $add = fn ($a: Int, $b: Int) { $a + $b }
# Default parameter values (stryke extension):
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} }
</code></pre>
<p>Default values are evaluated at call time if the argument is not provided.</p>
</article>
<article class="doc-entry" id="doc-struct">
<h3><a class="doc-anchor" href="#doc-struct">#</a> <code>struct</code></h3>
<p><code>struct</code> 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.</p>
<p>**Declaration:**</p>
<pre><code class="lang-perl">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)
</code></pre>
<p>**Construction:**</p>
<pre><code class="lang-perl">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
</code></pre>
<p>**Field access (getter/setter):**</p>
<pre><code class="lang-perl">p $p->x # getter (0 args)
$p->x(3.0) # setter (1 arg)
</code></pre>
<p>**User-defined methods:**</p>
<pre><code class="lang-perl">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)
</code></pre>
<p>**Built-in methods:**</p>
<pre><code class="lang-perl">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
</code></pre>
<p>**Smart stringify:**</p>
<pre><code class="lang-perl">p $p # Point(x => 1.5, y => 2)
</code></pre>
<p>**Structural equality:**</p>
<pre><code class="lang-perl">my $a = Point(1, 2)
my $b = Point(1, 2)
p $a == $b # 1 (compares all fields)
</code></pre>
<p>Note: field type is checked at construction and mutation; unknown field names are fatal errors.</p>
</article>
<article class="doc-entry" id="doc-typed">
<h3><a class="doc-anchor" href="#doc-typed">#</a> <code>typed</code></h3>
<p><code>typed</code> adds optional runtime type annotations to lexical variables and subroutine parameters. When a <code>typed</code> declaration is in effect, stryke inserts a lightweight check at assignment time that verifies the value matches the declared type (<code>Int</code>, <code>Str</code>, <code>Float</code>, <code>Bool</code>, <code>ArrayRef</code>, <code>HashRef</code>, or a user-defined <code>struct</code> 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.</p>
<pre><code class="lang-perl">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
</code></pre>
<p>Note: assigning a value of the wrong type raises a runtime exception immediately.</p>
<p>You can mix typed and untyped variables freely in the same scope, so adopting <code>typed</code> is incremental — annotate the variables that matter and leave the rest dynamic. Subroutine parameters declared with type annotations in <code>fn</code> are checked on every call, giving you contract-style validation at function boundaries without a separate assertion library.</p>
<pre><code class="lang-perl">typed my @nums : Int = (1, 2, 3)
typed my %cfg : Str = (host => "localhost", port => "8080")
</code></pre>
</article>
<article class="doc-entry" id="doc-match">
<h3><a class="doc-anchor" href="#doc-match">#</a> <code>match</code></h3>
<p>Algebraic pattern matching (stryke extension).</p>
<pre><code class="lang-perl">match ($val) {
/^\d+$/ => p "number: $val",
[1, 2, _] => p "array starting with 1,2",
{ name => $n } => p "name is $n",
_ => p "default",
}
</code></pre>
<p>Patterns: regex, array, hash, literal, wildcard <code>_</code>. Optional <code>if</code> guard per arm.</p>
</article>
<article class="doc-entry" id="doc-frozen">
<h3><a class="doc-anchor" href="#doc-frozen">#</a> <code>frozen</code></h3>
<p>Declare an immutable lexical variable. <code>const my</code> and <code>frozen my</code> are interchangeable spellings; <code>const</code> reads more naturally for engineers coming from other languages.</p>
<pre><code class="lang-perl">const my $pi = 3.14159
# $pi = 3 # ERROR: cannot assign to frozen variable
frozen my @primes = (2, 3, 5, 7, 11)
</code></pre>
</article>
<article class="doc-entry" id="doc-fore">
<h3><a class="doc-anchor" href="#doc-fore">#</a> <code>fore</code></h3>
<p>Side-effect-only list iterator (like <code>map</code> but void, returns item count).</p>
<pre><code class="lang-perl">qw(a b c) |> e p # prints a, b, c; returns 3
1..5 |> map $_ * 2 |> e p # prints 2,4,6,8,10
</code></pre>
</article>
<article class="doc-entry" id="doc-ep">
<h3><a class="doc-anchor" href="#doc-ep">#</a> <code>ep</code></h3>
<p><code>ep</code> — shorthand for <code>e { p }</code> (foreach + print). Iterates the list and prints each element.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-p">
<h3><a class="doc-anchor" href="#doc-p">#</a> <code>p</code></h3>
<p><code>p</code> — alias for <code>say</code> (print with newline).</p>
<pre><code class="lang-perl">p "hello" # hello\n
p 42 # 42\n
1..5 |> e p # prints each on its own line
</code></pre>
</article>
<article class="doc-entry" id="doc-gen">
<h3><a class="doc-anchor" href="#doc-gen">#</a> <code>gen</code></h3>
<p>Create a generator — lazy <code>yield</code> values on demand.</p>
<pre><code class="lang-perl">my $g = gen { yield $_ for 1..5 }
my ($val, $more) = @{$g->next}
</code></pre>
</article>
<article class="doc-entry" id="doc-yield">
<h3><a class="doc-anchor" href="#doc-yield">#</a> <code>yield</code></h3>
<p>Yield a value from inside a <code>gen { }</code> generator block, suspending the generator until the consumer calls <code>->next</code> again. Each <code>yield</code> 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 <code>yield</code> or Rust's <code>Iterator::next</code>.</p>
<pre><code class="lang-perl">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
}
</code></pre>
</article>
<article class="doc-entry" id="doc-trace">
<h3><a class="doc-anchor" href="#doc-trace">#</a> <code>trace</code></h3>
<p>Trace <code>mysync</code> mutations to stderr (tagged with worker index under <code>fan</code>).</p>
<pre><code class="lang-perl">trace { fan 10 { $counter++ } }
</code></pre>
</article>
<article class="doc-entry" id="doc-timer">
<h3><a class="doc-anchor" href="#doc-timer">#</a> <code>timer</code></h3>
<p>Measure wall-clock milliseconds for a block.</p>
<pre><code class="lang-perl">my $ms = timer { heavy_work() }
</code></pre>
</article>
<article class="doc-entry" id="doc-bench">
<h3><a class="doc-anchor" href="#doc-bench">#</a> <code>bench</code></h3>
<p>Benchmark a block N times; returns <code>"min/mean/p99"</code>.</p>
<pre><code class="lang-perl">my $report = bench { work() } 1000
</code></pre>
</article>
<article class="doc-entry" id="doc-eval-timeout">
<h3><a class="doc-anchor" href="#doc-eval-timeout">#</a> <code>eval_timeout</code></h3>
<p>Run a block with a wall-clock timeout (seconds).</p>
<pre><code class="lang-perl">eval_timeout 5 { slow_operation() }
</code></pre>
</article>
<article class="doc-entry" id="doc-retry">
<h3><a class="doc-anchor" href="#doc-retry">#</a> <code>retry</code></h3>
<p>Retry a block on failure.</p>
<pre><code class="lang-perl">retry { http_call() } times => 3, backoff => 'exponential'
</code></pre>
</article>
<article class="doc-entry" id="doc-rate-limit">
<h3><a class="doc-anchor" href="#doc-rate-limit">#</a> <code>rate_limit</code></h3>
<p>Limit invocations per time window.</p>
<pre><code class="lang-perl">rate_limit(10, "1s") { hit_api() }
</code></pre>
</article>
<article class="doc-entry" id="doc-every">
<h3><a class="doc-anchor" href="#doc-every">#</a> <code>every</code></h3>
<p>Run a block at a fixed interval.</p>
<pre><code class="lang-perl">every "500ms" { tick() }
</code></pre>
</article>
<article class="doc-entry" id="doc-watch">
<h3><a class="doc-anchor" href="#doc-watch">#</a> <code>watch</code></h3>
<p>Watch a single file for changes (non-parallel).</p>
<pre><code class="lang-perl">watch "/tmp/x", fn { process }
</code></pre>
</article>
<article class="doc-entry" id="doc-capture">
<h3><a class="doc-anchor" href="#doc-capture">#</a> <code>capture</code></h3>
<p>Run a command and capture structured output. Returns an object with <code>->stdout</code>, <code>->stderr</code>, <code>->exitcode</code>, and <code>->failed</code> methods. When piped to <code>lines</code> or <code>words</code>, stdout is auto-extracted so you can chain directly.</p>
<pre><code class="lang-perl">my $r = capture("ls -la")
p $r->stdout, $r->stderr, $r->exitcode
capture("ps aux") |> lines |> map { columns } |> tbl |> p
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-data-serialization">
<h2>Data & Serialization</h2>
<p class="chapter-meta">45 topics</p>
<article class="doc-entry" id="doc-json-encode">
<h3><a class="doc-anchor" href="#doc-json-encode">#</a> <code>json_encode</code></h3>
<p><code>json_encode</code> 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 <code>JSON::XS</code> 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 <code>json_decode</code> to round-trip back.</p>
<pre><code class="lang-perl">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`.
</code></pre>
</article>
<article class="doc-entry" id="doc-json-decode">
<h3><a class="doc-anchor" href="#doc-json-decode">#</a> <code>json_decode</code></h3>
<p><code>json_decode</code> 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.</p>
<pre><code class="lang-perl">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.
</code></pre>
</article>
<article class="doc-entry" id="doc-json-jq">
<h3><a class="doc-anchor" href="#doc-json-jq">#</a> <code>json_jq</code></h3>
<p><code>json_jq</code> applies a jq-style query expression to a stryke data structure and returns the matched value. This brings the power of the <code>jq</code> 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.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-to-json">
<h3><a class="doc-anchor" href="#doc-to-json">#</a> <code>to_json</code></h3>
<p><code>to_json</code> (alias <code>tj</code>) converts a stryke data structure into a JSON string, functioning as a convenient shorthand for <code>json_encode</code>. It accepts hashrefs, arrayrefs, scalars, and nested combinations, producing compact JSON output suitable for APIs, config files, or inter-process communication. The alias <code>tj</code> 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.</p>
<pre><code class="lang-perl">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"
</code></pre>
</article>
<article class="doc-entry" id="doc-to-csv">
<h3><a class="doc-anchor" href="#doc-to-csv">#</a> <code>to_csv</code></h3>
<p><code>to_csv</code> (alias <code>tc</code>) 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 <code>tc</code> keeps one-liners terse when piping query results or API responses straight to CSV.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-to-toml">
<h3><a class="doc-anchor" href="#doc-to-toml">#</a> <code>to_toml</code></h3>
<p><code>to_toml</code> (alias <code>tt</code>) serializes a stryke hashref into a TOML-formatted string. TOML is a popular configuration format that maps cleanly to hash structures, making <code>tt</code> 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 <code>toml_decode</code>.</p>
<pre><code class="lang-perl">my %cfg = (database => {host => "localhost", port => 5432}, debug => 1)
p tt \%cfg
# [database]
# host = "localhost"
# port = 5432
# debug = 1
tt(\%cfg) |> spurt "config.toml"
</code></pre>
</article>
<article class="doc-entry" id="doc-to-yaml">
<h3><a class="doc-anchor" href="#doc-to-yaml">#</a> <code>to_yaml</code></h3>
<p><code>to_yaml</code> (alias <code>ty</code>) 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 <code>yaml_decode</code>. The alias <code>ty</code> is convenient for quick inspection of complex data.</p>
<pre><code class="lang-perl">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"
</code></pre>
</article>
<article class="doc-entry" id="doc-to-xml">
<h3><a class="doc-anchor" href="#doc-to-xml">#</a> <code>to_xml</code></h3>
<p><code>to_xml</code> (alias <code>tx</code>) 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 <code>xml_decode</code>.</p>
<pre><code class="lang-perl">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"
</code></pre>
</article>
<article class="doc-entry" id="doc-to-html">
<h3><a class="doc-anchor" href="#doc-to-html">#</a> <code>to_html</code></h3>
<p><code>to_html</code> (alias <code>th</code>) 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.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-to-markdown">
<h3><a class="doc-anchor" href="#doc-to-markdown">#</a> <code>to_markdown</code></h3>
<p><code>to_markdown</code> (aliases <code>to_md</code>, <code>tmd</code>) 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.</p>
<pre><code class="lang-perl">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 |
</code></pre>
</article>
<article class="doc-entry" id="doc-from-json">
<h3><a class="doc-anchor" href="#doc-from-json">#</a> <code>from_json</code></h3>
<p><code>from_json</code> (alias <code>fj</code>) parses a JSON string into a stryke data structure (hashref, arrayref, scalar). This is the inverse of <code>to_json</code> and the idiomatic way to decode JSON responses from APIs, config files, or inter-process communication. The Rust-backed parser handles large documents efficiently.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-from-yaml">
<h3><a class="doc-anchor" href="#doc-from-yaml">#</a> <code>from_yaml</code></h3>
<p><code>from_yaml</code> (alias <code>fy</code>) 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.</p>
<pre><code class="lang-perl">my $yaml = "name: Alice\nage: 30"
my $data = from_yaml($yaml)
p $data->{name} # Alice
slurp("config.yaml") |> fy |> say $_->{database}{host}
</code></pre>
</article>
<article class="doc-entry" id="doc-from-toml">
<h3><a class="doc-anchor" href="#doc-from-toml">#</a> <code>from_toml</code></h3>
<p><code>from_toml</code> (alias <code>ftoml</code>) 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.</p>
<pre><code class="lang-perl">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}
</code></pre>
</article>
<article class="doc-entry" id="doc-from-xml">
<h3><a class="doc-anchor" href="#doc-from-xml">#</a> <code>from_xml</code></h3>
<p><code>from_xml</code> (alias <code>fx</code>) 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.</p>
<pre><code class="lang-perl">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}
</code></pre>
</article>
<article class="doc-entry" id="doc-from-csv">
<h3><a class="doc-anchor" href="#doc-from-csv">#</a> <code>from_csv</code></h3>
<p><code>from_csv</code> (alias <code>fcsv</code>) parses a CSV string into an arrayref of hashrefs, treating the first line as headers. This is the inverse of <code>to_csv</code> and handles quoted fields containing commas according to RFC 4180.</p>
<pre><code class="lang-perl">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 }
</code></pre>
</article>
<article class="doc-entry" id="doc-xopen">
<h3><a class="doc-anchor" href="#doc-xopen">#</a> <code>xopen</code></h3>
<p><code>xopen</code> (alias <code>xo</code>) opens a file or URL with the system default handler — <code>open</code> on macOS, <code>xdg-open</code> on Linux, <code>start</code> 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 <code>xopen</code> and the OS opens it in the appropriate app (browser for HTML, viewer for PDF, editor for text).</p>
<pre><code class="lang-perl">fr |> map +{name => $_, size => format_bytes(size)} |> th |> to_file("report.html") |> xopen
xopen "https://github.com/MenkeTechnologies/stryke"
xopen "output.pdf"
</code></pre>
</article>
<article class="doc-entry" id="doc-clip">
<h3><a class="doc-anchor" href="#doc-clip">#</a> <code>clip</code></h3>
<p><code>clip</code> (aliases <code>clipboard</code>, <code>pbcopy</code>) copies text to the system clipboard (<code>pbcopy</code> on macOS, <code>xclip</code>/<code>xsel</code> 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 <code>clip</code> and paste directly into Slack, GitHub, docs, or email.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-paste">
<h3><a class="doc-anchor" href="#doc-paste">#</a> <code>paste</code></h3>
<p><code>paste</code> (alias <code>pbpaste</code>) reads text from the system clipboard (<code>pbpaste</code> on macOS, <code>xclip</code>/<code>xsel</code> on Linux). Returns the clipboard contents as a string, ready for pipeline processing.</p>
<pre><code class="lang-perl">p paste # print clipboard contents
paste |> lines |> grep /error/i |> p # search clipboard for errors
paste |> wc |> p # word count of clipboard
</code></pre>
</article>
<article class="doc-entry" id="doc-to-table">
<h3><a class="doc-anchor" href="#doc-to-table">#</a> <code>to_table</code></h3>
<p><code>to_table</code> (aliases <code>table</code>, <code>tbl</code>) 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.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-sparkline">
<h3><a class="doc-anchor" href="#doc-sparkline">#</a> <code>sparkline</code></h3>
<p><code>sparkline</code> (alias <code>spark</code>) 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.</p>
<pre><code class="lang-perl">(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
</code></pre>
</article>
<article class="doc-entry" id="doc-bar-chart">
<h3><a class="doc-anchor" href="#doc-bar-chart">#</a> <code>bar_chart</code></h3>
<p><code>bar_chart</code> (alias <code>bars</code>) 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 <code>freq</code> for instant word/event counting visualization.</p>
<pre><code class="lang-perl">qw(a b a c a b) |> freq |> bars |> p
# a │ ████████████████████████████████████████ 3
# b │ ███████████████████████████ 2
# c │ █████████████ 1
bars({cpu => 73, mem => 45, disk => 91}) |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-flame">
<h3><a class="doc-anchor" href="#doc-flame">#</a> <code>flame</code></h3>
<p><code>flame</code> (alias <code>flamechart</code>) 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.</p>
<pre><code class="lang-perl">flame({main => {parse => 30, eval => {compile => 15, run => 45}}, init => 10}) |> p
my $profile = read_json "profile.json"
flame($profile) |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-histo">
<h3><a class="doc-anchor" href="#doc-histo">#</a> <code>histo</code></h3>
<p><code>histo</code> 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 <code>freq</code> for categorical data.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-gauge">
<h3><a class="doc-anchor" href="#doc-gauge">#</a> <code>gauge</code></h3>
<p><code>gauge</code> 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: <code>gauge(45, 100)</code>.</p>
<pre><code class="lang-perl">p gauge(0.73) # [██████████████████████░░░░░░░░] 73%
p gauge(45, 100) # [█████████████░░░░░░░░░░░░░░░░] 45%
</code></pre>
</article>
<article class="doc-entry" id="doc-spinner">
<h3><a class="doc-anchor" href="#doc-spinner">#</a> <code>spinner</code></h3>
<p><code>spinner</code> 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.</p>
<pre><code class="lang-perl">my $r = spinner "loading" { fetch_json("https://api.example.com/data") }
spinner { sleep 2
42 } # default message "working"
</code></pre>
</article>
<article class="doc-entry" id="doc-csv-read">
<h3><a class="doc-anchor" href="#doc-csv-read">#</a> <code>csv_read</code></h3>
<p><code>csv_read</code> (alias <code>cr</code>) 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.</p>
<pre><code class="lang-perl">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)
</code></pre>
</article>
<article class="doc-entry" id="doc-csv-write">
<h3><a class="doc-anchor" href="#doc-csv-write">#</a> <code>csv_write</code></h3>
<p><code>csv_write</code> (alias <code>cw</code>) 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 <code>csv_read</code> 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.</p>
<pre><code class="lang-perl">my @data = (["name", "age"], ["Alice", 30], ["Bob", 25])
csv_write(\@data) |> spurt "people.csv"
my @report = map { [$_->{id}, $_->{score}] } @results
p csv_write \@report
</code></pre>
</article>
<article class="doc-entry" id="doc-dataframe">
<h3><a class="doc-anchor" href="#doc-dataframe">#</a> <code>dataframe</code></h3>
<p><code>dataframe</code> (alias <code>df</code>) 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.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-sqlite">
<h3><a class="doc-anchor" href="#doc-sqlite">#</a> <code>sqlite</code></h3>
<p><code>sqlite</code> (alias <code>sql</code>) 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 <code>sqlite</code> a zero-setup embedded database.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-digits">
<h3><a class="doc-anchor" href="#doc-digits">#</a> <code>digits</code></h3>
<p><code>digits</code> (alias <code>dg</code>) 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 <code>join</code> to reconstruct the numeric string, or <code>freq</code> for digit distribution analysis.</p>
<pre><code class="lang-perl">p join "", digits("phone: 555-1234") # 5551234
"abc123def456" |> digits |> cnt |> p # 6
cat("log.txt") |> digits |> freq |> bars |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-letters">
<h3><a class="doc-anchor" href="#doc-letters">#</a> <code>letters</code></h3>
<p><code>letters</code> (alias <code>lts</code>) extracts all alphabetic characters from a string and returns them as a list. Filters out digits, punctuation, whitespace — keeps only letters.</p>
<pre><code class="lang-perl">p join "", letters("h3ll0 w0rld!") # hllwrld
"abc123DEF" |> letters |> cnt |> p # 6
</code></pre>
</article>
<article class="doc-entry" id="doc-sentences">
<h3><a class="doc-anchor" href="#doc-sentences">#</a> <code>sentences</code></h3>
<p><code>sentences</code> (alias <code>sents</code>) splits text on sentence boundaries (<code>.</code> <code>!</code> <code>?</code> 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.</p>
<pre><code class="lang-perl">"Hello world. How are you? Fine!" |> sentences |> e p
# Hello world.
# How are you?
# Fine!
cat("essay.txt") |> sentences |> cnt |> p # sentence count
</code></pre>
</article>
<article class="doc-entry" id="doc-paragraphs">
<h3><a class="doc-anchor" href="#doc-paragraphs">#</a> <code>paragraphs</code></h3>
<p><code>paragraphs</code> (alias <code>paras</code>) 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.</p>
<pre><code class="lang-perl">cat("README.md") |> paragraphs |> cnt |> p # paragraph count
cat("essay.txt") |> paragraphs |> map { sentences |> cnt } |> spark |> p # sentences per paragraph
</code></pre>
</article>
<article class="doc-entry" id="doc-sections">
<h3><a class="doc-anchor" href="#doc-sections">#</a> <code>sections</code></h3>
<p><code>sections</code> (alias <code>sects</code>) splits text on markdown-style headers (<code># ...</code>, <code>## ...</code>) or lines of <code>===</code>/<code>---</code>. Returns a list of arrayrefs <code>[heading, body]</code> where each section's heading and body are separated. Useful for parsing structured documents.</p>
<pre><code class="lang-perl">cat("README.md") |> sections |> cnt |> p # section count
cat("README.md") |> sections |> map { $_->[0] } |> e p # list all headings
</code></pre>
</article>
<article class="doc-entry" id="doc-numbers">
<h3><a class="doc-anchor" href="#doc-numbers">#</a> <code>numbers</code></h3>
<p><code>numbers</code> (alias <code>nums</code>) extracts all numbers (integers and floats, including negatives) from a string and returns them as numeric values. Unlike <code>digits</code> which returns individual digit characters, <code>numbers</code> returns actual parsed values. Useful for pulling measurements, scores, or IDs out of mixed text.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-graphemes">
<h3><a class="doc-anchor" href="#doc-graphemes">#</a> <code>graphemes</code></h3>
<p><code>graphemes</code> (alias <code>grs</code>) splits a string into Unicode grapheme clusters. Unlike <code>chars</code> which splits on code points, <code>graphemes</code> keeps combining marks and emoji sequences together as single visual units. <code>"cafe\u{0301}"</code> gives 4 graphemes (not 5 code points). Essential for correct text processing of accented characters, emoji, and non-Latin scripts.</p>
<pre><code class="lang-perl">p cnt graphemes("cafe\u{0301}") # 4 (not 5)
graphemes("hello") |> e p # h, e, l, l, o
</code></pre>
</article>
<article class="doc-entry" id="doc-columns">
<h3><a class="doc-anchor" href="#doc-columns">#</a> <code>columns</code></h3>
<p><code>columns</code> (alias <code>cols</code>) splits fixed-width columnar text into fields. Without a widths argument, it auto-detects columns by splitting on runs of 2+ whitespace (ideal for <code>ps aux</code>, <code>ls -l</code>, <code>df</code> output). With an arrayref of widths, it splits at exact fixed positions. Pairs with <code>lines</code> for processing tabular command output.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-stringify">
<h3><a class="doc-anchor" href="#doc-stringify">#</a> <code>stringify</code></h3>
<p><code>stringify</code> (alias <code>str</code>) 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 <code>eval</code> 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 <code>dd</code>, which targets human readability, <code>str</code> prioritizes parseability.</p>
<pre><code class="lang-perl">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]
</code></pre>
<p>Note: references are serialized recursively; circular references will cause infinite recursion.</p>
</article>
<article class="doc-entry" id="doc-ddump">
<h3><a class="doc-anchor" href="#doc-ddump">#</a> <code>ddump</code></h3>
<p><code>ddump</code> (alias <code>dd</code>) pretty-prints any stryke data structure to stderr in a human-readable, indented format similar to Perl's <code>Data::Dumper</code>. It is the go-to tool for quick debugging — drop a <code>dd</code> call anywhere in a pipeline to inspect intermediate values without disrupting the data flow. The output is colorized when stderr is a terminal. Unlike <code>str</code>, the output is not meant for <code>eval</code> round-tripping; it prioritizes clarity over parseability. <code>dd</code> returns its argument unchanged, so it can be inserted into pipelines transparently.</p>
<pre><code class="lang-perl">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
</code></pre>
<p>Note: <code>dd</code> writes to stderr, not stdout, so it never contaminates pipeline output.</p>
</article>
<article class="doc-entry" id="doc-toml-decode">
<h3><a class="doc-anchor" href="#doc-toml-decode">#</a> <code>toml_decode</code></h3>
<p><code>toml_decode</code> (alias <code>td</code>) 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.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-toml-encode">
<h3><a class="doc-anchor" href="#doc-toml-encode">#</a> <code>toml_encode</code></h3>
<p><code>toml_encode</code> (alias <code>te</code>) serializes a stryke hashref into a valid TOML string. Nested hashes become TOML sections with <code>[section]</code> headers, arrays become TOML arrays, and scalars are serialized with appropriate quoting. This is the inverse of <code>toml_decode</code> and is useful for generating or updating configuration files programmatically. The output is human-readable and can be written directly to a <code>.toml</code> file.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-yaml-decode">
<h3><a class="doc-anchor" href="#doc-yaml-decode">#</a> <code>yaml_decode</code></h3>
<p><code>yaml_decode</code> (alias <code>yd</code>) 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.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-yaml-encode">
<h3><a class="doc-anchor" href="#doc-yaml-encode">#</a> <code>yaml_encode</code></h3>
<p><code>yaml_encode</code> (alias <code>ye</code>) 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 <code>yaml_decode</code>.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-xml-decode">
<h3><a class="doc-anchor" href="#doc-xml-decode">#</a> <code>xml_decode</code></h3>
<p><code>xml_decode</code> (alias <code>xd</code>) 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.</p>
<pre><code class="lang-perl">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}
</code></pre>
</article>
<article class="doc-entry" id="doc-xml-encode">
<h3><a class="doc-anchor" href="#doc-xml-encode">#</a> <code>xml_encode</code></h3>
<p><code>xml_encode</code> (alias <code>xe</code>) 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 <code>xml_decode</code> and round-trips cleanly.</p>
<pre><code class="lang-perl">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)
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-http-networking">
<h2>HTTP & Networking</h2>
<p class="chapter-meta">23 topics</p>
<article class="doc-entry" id="doc-fetch">
<h3><a class="doc-anchor" href="#doc-fetch">#</a> <code>fetch</code></h3>
<p><code>fetch</code> (alias <code>ft</code>) 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 <code>fetch_json</code> which additionally decodes the response.</p>
<pre><code class="lang-perl">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.
</code></pre>
</article>
<article class="doc-entry" id="doc-fetch-json">
<h3><a class="doc-anchor" href="#doc-fetch-json">#</a> <code>fetch_json</code></h3>
<p><code>fetch_json</code> (alias <code>ftj</code>) performs a blocking HTTP GET request and automatically decodes the JSON response body into a stryke data structure. This combines <code>fetch</code> and <code>json_decode</code> 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.</p>
<pre><code class="lang-perl">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}
</code></pre>
</article>
<article class="doc-entry" id="doc-fetch-async">
<h3><a class="doc-anchor" href="#doc-fetch-async">#</a> <code>fetch_async</code></h3>
<p><code>fetch_async</code> (alias <code>fta</code>) 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 <code>fetch</code>. Use this when you need to parallelize network I/O without threads.</p>
<pre><code class="lang-perl">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"
</code></pre>
</article>
<article class="doc-entry" id="doc-fetch-async-json">
<h3><a class="doc-anchor" href="#doc-fetch-async-json">#</a> <code>fetch_async_json</code></h3>
<p><code>fetch_async_json</code> (alias <code>ftaj</code>) initiates a non-blocking HTTP GET request that automatically decodes the JSON response when awaited. This combines <code>fetch_async</code> with <code>json_decode</code>, 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.</p>
<pre><code class="lang-perl">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} }
</code></pre>
</article>
<article class="doc-entry" id="doc-http-request">
<h3><a class="doc-anchor" href="#doc-http-request">#</a> <code>http_request</code></h3>
<p><code>http_request</code> (alias <code>hr</code>) performs a fully configurable HTTP request with control over method, headers, body, and timeout. Unlike <code>fetch</code> which is limited to GET, <code>http_request</code> supports POST, PUT, PATCH, DELETE, and any other HTTP method. Pass named parameters for configuration. The response is returned as a hashref containing <code>status</code>, <code>headers</code>, and <code>body</code> 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.</p>
<pre><code class="lang-perl">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")
</code></pre>
</article>
<article class="doc-entry" id="doc-par-fetch">
<h3><a class="doc-anchor" href="#doc-par-fetch">#</a> <code>par_fetch</code></h3>
<p><code>par_fetch @urls</code> — fetch a list of URLs in parallel using async HTTP, returning an array of response bodies in input order.</p>
<p>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 <code>http_request</code> inside <code>pmap</code> instead. <code>par_fetch</code> 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.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-serve">
<h3><a class="doc-anchor" href="#doc-serve">#</a> <code>serve</code></h3>
<p>Start a blocking HTTP server.</p>
<pre><code class="lang-perl">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 `[`.
</code></pre>
</article>
<article class="doc-entry" id="doc-socket">
<h3><a class="doc-anchor" href="#doc-socket">#</a> <code>socket</code></h3>
<p>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 <code>bind</code>, <code>connect</code>, <code>send</code>, <code>recv</code>, and other socket operations. Domain constants include <code>AF_INET</code> (IPv4) and <code>AF_INET6</code> (IPv6); type constants include <code>SOCK_STREAM</code> (TCP) and <code>SOCK_DGRAM</code> (UDP).</p>
<pre><code class="lang-perl">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)
</code></pre>
</article>
<article class="doc-entry" id="doc-bind">
<h3><a class="doc-anchor" href="#doc-bind">#</a> <code>bind</code></h3>
<p>Bind a socket to a local address so it can accept connections or receive datagrams on that address. The address is a packed <code>sockaddr_in</code> or <code>sockaddr_in6</code> structure. Binding is required before calling <code>listen</code> on a server socket. Dies if the address is already in use unless <code>SO_REUSEADDR</code> is set.</p>
<pre><code class="lang-perl">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)
</code></pre>
</article>
<article class="doc-entry" id="doc-listen">
<h3><a class="doc-anchor" href="#doc-listen">#</a> <code>listen</code></h3>
<p>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 <code>accept</code> in a loop after <code>listen</code> to handle clients.</p>
<pre><code class="lang-perl">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)
}
</code></pre>
</article>
<article class="doc-entry" id="doc-accept">
<h3><a class="doc-anchor" href="#doc-accept">#</a> <code>accept</code></h3>
<p>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.</p>
<pre><code class="lang-perl">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)
}
</code></pre>
</article>
<article class="doc-entry" id="doc-connect">
<h3><a class="doc-anchor" href="#doc-connect">#</a> <code>connect</code></h3>
<p>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 <code>send</code> calls do not need an address. Dies or returns false if the connection is refused or times out.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-send">
<h3><a class="doc-anchor" href="#doc-send">#</a> <code>send</code></h3>
<p>Send data through a connected socket. The flags argument controls behavior — use <code>0</code> for normal sends. For UDP sockets you can supply a destination address as a fourth argument to send to a specific peer without calling <code>connect</code> first. Returns the number of bytes sent, or <code>undef</code> on error.</p>
<pre><code class="lang-perl">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")))
</code></pre>
</article>
<article class="doc-entry" id="doc-recv">
<h3><a class="doc-anchor" href="#doc-recv">#</a> <code>recv</code></h3>
<p>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.</p>
<pre><code class="lang-perl">recv($sock, my $buf, 4096, 0) or die "recv: $!"
p $buf
my $data = ""
while (recv($sock, my $chunk, 8192, 0) && length($chunk)) {
$data .= $chunk
}
</code></pre>
</article>
<article class="doc-entry" id="doc-shutdown">
<h3><a class="doc-anchor" href="#doc-shutdown">#</a> <code>shutdown</code></h3>
<p>Shut down part or all of a socket connection without closing the file descriptor. The <code>how</code> argument controls direction: <code>0</code> stops reading, <code>1</code> stops writing (sends FIN to peer), <code>2</code> stops both. This is useful for signaling end-of-data to the remote side while still reading its response.</p>
<pre><code class="lang-perl">send($sock, $request, 0)
shutdown($sock, 1) # done writing
recv($sock, my $resp, 65536, 0) # still read response
shutdown($sock, 2) # fully close
</code></pre>
</article>
<article class="doc-entry" id="doc-setsockopt">
<h3><a class="doc-anchor" href="#doc-setsockopt">#</a> <code>setsockopt</code></h3>
<p>Set an option on a socket at the specified protocol level. Common uses include enabling <code>SO_REUSEADDR</code> to allow immediate rebinding after a server restart, setting <code>TCP_NODELAY</code> to disable Nagle's algorithm, or adjusting buffer sizes. The value is typically a packed integer.</p>
<pre><code class="lang-perl">setsockopt($srv, SOL_SOCKET, SO_REUSEADDR, 1)
setsockopt($sock, IPPROTO_TCP, TCP_NODELAY, 1)
setsockopt($sock, SOL_SOCKET, SO_RCVBUF, pack("I", 262144))
</code></pre>
</article>
<article class="doc-entry" id="doc-getsockopt">
<h3><a class="doc-anchor" href="#doc-getsockopt">#</a> <code>getsockopt</code></h3>
<p>Retrieve the current value of a socket option at the specified protocol level. Returns the option value as a packed binary string — use <code>unpack</code> to interpret it. Useful for inspecting buffer sizes, checking whether <code>SO_REUSEADDR</code> is set, or reading OS-assigned values.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-getsockname">
<h3><a class="doc-anchor" href="#doc-getsockname">#</a> <code>getsockname</code></h3>
<p>Return the packed socket address of the local end of a socket. This is useful when the socket was bound to <code>INADDR_ANY</code> or port <code>0</code> (OS-assigned) and you need to discover the actual address and port the OS chose. Unpack the result with <code>sockaddr_in</code>.</p>
<pre><code class="lang-perl">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"
</code></pre>
</article>
<article class="doc-entry" id="doc-getpeername">
<h3><a class="doc-anchor" href="#doc-getpeername">#</a> <code>getpeername</code></h3>
<p>Return the packed socket address of the remote end of a connected socket. Use <code>sockaddr_in</code> or <code>sockaddr_in6</code> to unpack it into a port and IP address. This is how a server discovers which client it is talking to after <code>accept</code>, or how a client confirms the peer address after <code>connect</code>.</p>
<pre><code class="lang-perl">my $packed = getpeername($client)
my ($port, $ip) = sockaddr_in($packed)
p "peer: " . inet_ntoa($ip) . ":$port"
</code></pre>
</article>
<article class="doc-entry" id="doc-gethostbyname">
<h3><a class="doc-anchor" href="#doc-gethostbyname">#</a> <code>gethostbyname</code></h3>
<p>Resolve a hostname to its network addresses using the system resolver. Returns <code>($name, $aliases, $addrtype, $length, @addrs)</code>. The addresses are packed binary — pass them through <code>inet_ntoa</code> to get dotted-quad strings. This is the classic DNS forward-lookup function.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-gethostbyaddr">
<h3><a class="doc-anchor" href="#doc-gethostbyaddr">#</a> <code>gethostbyaddr</code></h3>
<p>Perform a reverse DNS lookup — given a packed binary IP address and address family, return the hostname associated with that address. Returns <code>($name, $aliases, $addrtype, $length, @addrs)</code> on success, or empty list if no PTR record exists.</p>
<pre><code class="lang-perl">my $packed = inet_aton("8.8.8.8")
my $name = (gethostbyaddr($packed, AF_INET))[0]
p $name # dns.google
</code></pre>
</article>
<article class="doc-entry" id="doc-getprotobyname">
<h3><a class="doc-anchor" href="#doc-getprotobyname">#</a> <code>getprotobyname</code></h3>
<p>Look up a network protocol by its name and return protocol information. Returns <code>($name, $aliases, $proto_number)</code>. The protocol number is what you pass to <code>socket</code> as the protocol argument. Common names include <code>tcp</code>, <code>udp</code>, and <code>icmp</code>.</p>
<pre><code class="lang-perl">my ($name, $aliases, $proto) = getprotobyname("tcp")
p "$name = protocol $proto" # tcp = protocol 6
socket(my $raw, AF_INET, SOCK_RAW, (getprotobyname("icmp"))[2])
</code></pre>
</article>
<article class="doc-entry" id="doc-getservbyname">
<h3><a class="doc-anchor" href="#doc-getservbyname">#</a> <code>getservbyname</code></h3>
<p>Look up a network service by its name and protocol, returning the port number and related information. Returns <code>($name, $aliases, $port, $proto)</code>. The port is in host byte order. This resolves well-known service names like <code>http</code>, <code>ssh</code>, or <code>smtp</code> to their port numbers portably.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-crypto-encoding">
<h2>Crypto & Encoding</h2>
<p class="chapter-meta">133 topics</p>
<article class="doc-entry" id="doc-sha256">
<h3><a class="doc-anchor" href="#doc-sha256">#</a> <code>sha256</code></h3>
<p><code>sha256</code> (alias <code>s256</code>) 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>
<pre><code class="lang-perl">p sha256 "hello world" # b94d27b9934d3e08...
my $checksum = sha256 slurp "release.tar.gz"
p $checksum
rl("passwords.txt") |> map sha256 |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-sha224">
<h3><a class="doc-anchor" href="#doc-sha224">#</a> <code>sha224</code></h3>
<p><code>sha224</code> (alias <code>s224</code>) 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>
<pre><code class="lang-perl">p sha224 "hello world" # 2f05477fc24bb4fa...
my $h = sha224(tj {key => "value"})
p $h
</code></pre>
</article>
<article class="doc-entry" id="doc-sha384">
<h3><a class="doc-anchor" href="#doc-sha384">#</a> <code>sha384</code></h3>
<p><code>sha384</code> (alias <code>s384</code>) 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>
<pre><code class="lang-perl">p sha384 "hello world" # fdbd8e75a67f29f7...
my $sig = sha384(slurp "document.pdf")
spurt "document.pdf.sha384", $sig
</code></pre>
</article>
<article class="doc-entry" id="doc-sha512">
<h3><a class="doc-anchor" href="#doc-sha512">#</a> <code>sha512</code></h3>
<p><code>sha512</code> (alias <code>s512</code>) 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>
<pre><code class="lang-perl">p sha512 "hello world" # 309ecc489c12d6eb...
my $hash = sha512(slurp "firmware.bin")
p $hash
my @hashes = map sha512 @files
</code></pre>
</article>
<article class="doc-entry" id="doc-sha1">
<h3><a class="doc-anchor" href="#doc-sha1">#</a> <code>sha1</code></h3>
<p><code>sha1</code> (alias <code>s1</code>) 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>
<pre><code class="lang-perl">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.
</code></pre>
</article>
<article class="doc-entry" id="doc-crc32">
<h3><a class="doc-anchor" href="#doc-crc32">#</a> <code>crc32</code></h3>
<p><code>crc32</code> 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>
<pre><code class="lang-perl">p crc32 "hello world" # 222957957
my $chk = crc32(slurp "archive.zip")
p sprintf "0x%08x", $chk # hex representation
my @checksums = map crc32 @chunks
</code></pre>
</article>
<article class="doc-entry" id="doc-hmac-sha256">
<h3><a class="doc-anchor" href="#doc-hmac-sha256">#</a> <code>hmac_sha256</code></h3>
<p><code>hmac_sha256</code> (alias <code>hmac</code>) 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.</p>
<pre><code class="lang-perl">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"
</code></pre>
</article>
<article class="doc-entry" id="doc-blake2b">
<h3><a class="doc-anchor" href="#doc-blake2b">#</a> <code>blake2b</code></h3>
<p><code>blake2b</code> (alias <code>b2b</code>) 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>
<pre><code class="lang-perl">p blake2b "hello world" # 021ced8799...
my $hash = b2b(slurp "large-file.bin")
my @hashes = map blake2b @messages
</code></pre>
</article>
<article class="doc-entry" id="doc-blake2s">
<h3><a class="doc-anchor" href="#doc-blake2s">#</a> <code>blake2s</code></h3>
<p><code>blake2s</code> (alias <code>b2s</code>) 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>
<pre><code class="lang-perl">p blake2s "hello world" # 9aec6806...
my $checksum = b2s($firmware_blob)
</code></pre>
</article>
<article class="doc-entry" id="doc-blake3">
<h3><a class="doc-anchor" href="#doc-blake3">#</a> <code>blake3</code></h3>
<p><code>blake3</code> (alias <code>b3</code>) 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>
<pre><code class="lang-perl">p blake3 "hello world" # d74981efa...
my $hash = b3(slurp "gigabyte-file.bin") # fast!
</code></pre>
</article>
<article class="doc-entry" id="doc-argon2-hash">
<h3><a class="doc-anchor" href="#doc-argon2-hash">#</a> <code>argon2_hash</code></h3>
<p><code>argon2_hash</code> (alias <code>argon2</code>) 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.</p>
<pre><code class="lang-perl">my $hash = argon2_hash("user-password")
to_file("user.hash", $hash)
# later...
if (argon2_verify("user-password", $hash)) {
p "login successful"
}
</code></pre>
</article>
<article class="doc-entry" id="doc-argon2-verify">
<h3><a class="doc-anchor" href="#doc-argon2-verify">#</a> <code>argon2_verify</code></h3>
<p><code>argon2_verify</code> 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.</p>
<pre><code class="lang-perl">my $stored = rl("user.hash")
if (argon2_verify($user_input, $stored)) {
p "access granted"
} else {
p "invalid password"
}
</code></pre>
</article>
<article class="doc-entry" id="doc-bcrypt-hash">
<h3><a class="doc-anchor" href="#doc-bcrypt-hash">#</a> <code>bcrypt_hash</code></h3>
<p><code>bcrypt_hash</code> (alias <code>bcrypt</code>) hashes a password using the bcrypt algorithm, returning a standard <code>$2b$...</code> 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.</p>
<pre><code class="lang-perl">my $hash = bcrypt_hash("my-password")
p $hash # $2b$12$...
if (bcrypt_verify("my-password", $hash)) {
p "correct"
}
</code></pre>
</article>
<article class="doc-entry" id="doc-bcrypt-verify">
<h3><a class="doc-anchor" href="#doc-bcrypt-verify">#</a> <code>bcrypt_verify</code></h3>
<p><code>bcrypt_verify</code> 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.</p>
<pre><code class="lang-perl">if (bcrypt_verify($password, $stored_hash)) {
grant_access()
}
</code></pre>
</article>
<article class="doc-entry" id="doc-scrypt-hash">
<h3><a class="doc-anchor" href="#doc-scrypt-hash">#</a> <code>scrypt_hash</code></h3>
<p><code>scrypt_hash</code> (alias <code>scrypt</code>) 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.</p>
<pre><code class="lang-perl">my $hash = scrypt_hash("password123")
if (scrypt_verify("password123", $hash)) {
p "verified"
}
</code></pre>
</article>
<article class="doc-entry" id="doc-scrypt-verify">
<h3><a class="doc-anchor" href="#doc-scrypt-verify">#</a> <code>scrypt_verify</code></h3>
<p><code>scrypt_verify</code> verifies a password against a scrypt PHC hash. Returns 1 on match, 0 otherwise.</p>
<pre><code class="lang-perl">if (scrypt_verify($input, $stored)) {
p "valid"
}
</code></pre>
</article>
<article class="doc-entry" id="doc-pbkdf2">
<h3><a class="doc-anchor" href="#doc-pbkdf2">#</a> <code>pbkdf2</code></h3>
<p><code>pbkdf2</code> (alias <code>pbkdf2_derive</code>) 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).</p>
<pre><code class="lang-perl">my $key = pbkdf2("password", "random-salt")
p $key # 64 hex chars = 32 bytes
my $strong = pbkdf2("pass", $salt, 200_000) # more iterations
</code></pre>
</article>
<article class="doc-entry" id="doc-random-bytes">
<h3><a class="doc-anchor" href="#doc-random-bytes">#</a> <code>random_bytes</code></h3>
<p><code>random_bytes</code> (alias <code>randbytes</code>) 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 <code>rand()</code> for cryptographic purposes.</p>
<pre><code class="lang-perl">my $key = random_bytes(32) # 256-bit key
my $nonce = random_bytes(12) # 96-bit nonce for AES-GCM
p hex_encode($key)
</code></pre>
</article>
<article class="doc-entry" id="doc-random-bytes-hex">
<h3><a class="doc-anchor" href="#doc-random-bytes-hex">#</a> <code>random_bytes_hex</code></h3>
<p><code>random_bytes_hex</code> (alias <code>randhex</code>) 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.</p>
<pre><code class="lang-perl">my $token = random_bytes_hex(16) # 32 hex chars
p $token # 7a3f9b2c1d...
my $api_key = "sk_" . randhex(24)
</code></pre>
</article>
<article class="doc-entry" id="doc-aes-encrypt">
<h3><a class="doc-anchor" href="#doc-aes-encrypt">#</a> <code>aes_encrypt</code></h3>
<p><code>aes_encrypt</code> (alias <code>aes_enc</code>) encrypts plaintext using AES-256-GCM authenticated encryption. Takes a 32-byte key (use <code>random_bytes(32)</code> or <code>pbkdf2</code>). Returns a base64 string containing the nonce and ciphertext. AES-GCM provides both confidentiality and integrity — tampering is detected on decryption.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-aes-decrypt">
<h3><a class="doc-anchor" href="#doc-aes-decrypt">#</a> <code>aes_decrypt</code></h3>
<p><code>aes_decrypt</code> (alias <code>aes_dec</code>) decrypts AES-256-GCM ciphertext produced by <code>aes_encrypt</code>. Takes the same 32-byte key and the base64 ciphertext. Dies if the key is wrong or the ciphertext was tampered with (authentication failure).</p>
<pre><code class="lang-perl">my $plain = aes_decrypt($key, $ciphertext)
p $plain
# wrong key or tampered data raises exception
</code></pre>
</article>
<article class="doc-entry" id="doc-chacha-encrypt">
<h3><a class="doc-anchor" href="#doc-chacha-encrypt">#</a> <code>chacha_encrypt</code></h3>
<p><code>chacha_encrypt</code> (alias <code>chacha_enc</code>) 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.</p>
<pre><code class="lang-perl">my $key = random_bytes(32)
my $cipher = chacha_encrypt($key, "secret data")
my $plain = chacha_decrypt($key, $cipher)
p $plain
</code></pre>
</article>
<article class="doc-entry" id="doc-chacha-decrypt">
<h3><a class="doc-anchor" href="#doc-chacha-decrypt">#</a> <code>chacha_decrypt</code></h3>
<p><code>chacha_decrypt</code> (alias <code>chacha_dec</code>) decrypts ChaCha20-Poly1305 ciphertext. Takes the same 32-byte key and base64 ciphertext. Dies on wrong key or tampering.</p>
<pre><code class="lang-perl">my $plain = chacha_decrypt($key, $cipher)
p $plain
</code></pre>
</article>
<article class="doc-entry" id="doc-ed25519-keygen">
<h3><a class="doc-anchor" href="#doc-ed25519-keygen">#</a> <code>ed25519_keygen</code></h3>
<p><code>ed25519_keygen</code> (alias <code>ed_keygen</code>) 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.</p>
<pre><code class="lang-perl">my ($priv, $pub) = @{ ed25519_keygen() }
p "Private: $priv"
p "Public: $pub"
my $sig = ed25519_sign($priv, "message")
</code></pre>
</article>
<article class="doc-entry" id="doc-ed25519-sign">
<h3><a class="doc-anchor" href="#doc-ed25519-sign">#</a> <code>ed25519_sign</code></h3>
<p><code>ed25519_sign</code> (alias <code>ed_sign</code>) 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.</p>
<pre><code class="lang-perl">my $sig = ed25519_sign($private_key, "hello world")
p $sig # 128 hex chars
</code></pre>
</article>
<article class="doc-entry" id="doc-ed25519-verify">
<h3><a class="doc-anchor" href="#doc-ed25519-verify">#</a> <code>ed25519_verify</code></h3>
<p><code>ed25519_verify</code> (alias <code>ed_verify</code>) 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.</p>
<pre><code class="lang-perl">if (ed25519_verify($pub, "hello world", $sig)) {
p "signature valid"
} else {
p "FORGED!"
}
</code></pre>
</article>
<article class="doc-entry" id="doc-x25519-keygen">
<h3><a class="doc-anchor" href="#doc-x25519-keygen">#</a> <code>x25519_keygen</code></h3>
<p><code>x25519_keygen</code> (alias <code>x_keygen</code>) 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.</p>
<pre><code class="lang-perl">my ($my_priv, $my_pub) = @{ x25519_keygen() }
# send $my_pub to peer, receive $their_pub
my $shared = x25519_dh($my_priv, $their_pub)
</code></pre>
</article>
<article class="doc-entry" id="doc-x25519-dh">
<h3><a class="doc-anchor" href="#doc-x25519-dh">#</a> <code>x25519_dh</code></h3>
<p><code>x25519_dh</code> (alias <code>x_dh</code>) 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.</p>
<pre><code class="lang-perl">my $shared = x25519_dh($my_private, $their_public)
my $key = hex_decode(substr($shared, 0, 64)) # use as AES key
</code></pre>
</article>
<article class="doc-entry" id="doc-base64-encode">
<h3><a class="doc-anchor" href="#doc-base64-encode">#</a> <code>base64_encode</code></h3>
<p><code>base64_encode</code> (alias <code>b64e</code>) 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 <code>=</code> as needed. Use <code>base64_decode</code> to reverse the encoding.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-base64-decode">
<h3><a class="doc-anchor" href="#doc-base64-decode">#</a> <code>base64_decode</code></h3>
<p><code>base64_decode</code> (alias <code>b64d</code>) 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.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-hex-encode">
<h3><a class="doc-anchor" href="#doc-hex-encode">#</a> <code>hex_encode</code></h3>
<p><code>hex_encode</code> (alias <code>hxe</code>) 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>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-hex-decode">
<h3><a class="doc-anchor" href="#doc-hex-decode">#</a> <code>hex_decode</code></h3>
<p><code>hex_decode</code> (alias <code>hxd</code>) converts a hexadecimal string back to its original bytes, interpreting every two hex characters as one byte. This is the inverse of <code>hex_encode</code> 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.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-uuid">
<h3><a class="doc-anchor" href="#doc-uuid">#</a> <code>uuid</code></h3>
<p><code>uuid</code> 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.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-jwt-encode">
<h3><a class="doc-anchor" href="#doc-jwt-encode">#</a> <code>jwt_encode</code></h3>
<p><code>jwt_encode</code> 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.</p>
<pre><code class="lang-perl">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"})
</code></pre>
</article>
<article class="doc-entry" id="doc-jwt-decode">
<h3><a class="doc-anchor" href="#doc-jwt-decode">#</a> <code>jwt_decode</code></h3>
<p><code>jwt_decode</code> 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 <code>exp</code> 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 <code>jwt_decode_unsafe</code> in production.</p>
<pre><code class="lang-perl">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"
}
</code></pre>
<p>Note: raises an exception on expired tokens, invalid signatures, or malformed input.</p>
</article>
<article class="doc-entry" id="doc-jwt-decode-unsafe">
<h3><a class="doc-anchor" href="#doc-jwt-decode-unsafe">#</a> <code>jwt_decode_unsafe</code></h3>
<p><code>jwt_decode_unsafe</code> 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.</p>
<pre><code class="lang-perl"># 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.
</code></pre>
</article>
<article class="doc-entry" id="doc-url-encode">
<h3><a class="doc-anchor" href="#doc-url-encode">#</a> <code>url_encode</code></h3>
<p>Percent-encode a string so it is safe to embed in a URL query parameter or path segment. Unreserved characters (alphanumeric, <code>-</code>, <code>_</code>, <code>.</code>, <code>~</code>) are left as-is; everything else becomes <code>%XX</code>. The alias <code>uri_escape</code> matches the classic <code>URI::Escape</code> name for Perl muscle-memory.</p>
<pre><code class="lang-perl">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.
</code></pre>
</article>
<article class="doc-entry" id="doc-url-decode">
<h3><a class="doc-anchor" href="#doc-url-decode">#</a> <code>url_decode</code></h3>
<p>Decode a percent-encoded string back to its original form, converting <code>%XX</code> sequences to the corresponding bytes and <code>+</code> to space. The alias <code>uri_unescape</code> matches <code>URI::Escape</code> conventions. Use this when parsing query strings from incoming URLs or reading URL-encoded form data.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-gzip">
<h3><a class="doc-anchor" href="#doc-gzip">#</a> <code>gzip</code></h3>
<p>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 <code>gunzip</code> for decompression. The compression level is chosen automatically for a good speed/size tradeoff.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-gunzip">
<h3><a class="doc-anchor" href="#doc-gunzip">#</a> <code>gunzip</code></h3>
<p>Decompress gzip-compressed data (RFC 1952) and return the original bytes. Dies if the input is not valid gzip. Use this to read <code>.gz</code> files or decompress data received from HTTP responses with <code>Content-Encoding: gzip</code>. Always the inverse of <code>gzip</code>.</p>
<pre><code class="lang-perl">my $compressed = rl("archive.gz")
my $text = gunzip($compressed)
p $text
# round-trip in a pipeline
"payload" |> gzip |> gunzip |> p # payload
</code></pre>
</article>
<article class="doc-entry" id="doc-zstd">
<h3><a class="doc-anchor" href="#doc-zstd">#</a> <code>zstd</code></h3>
<p>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 <code>zstd_decode</code> for decompression.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-zstd-decode">
<h3><a class="doc-anchor" href="#doc-zstd-decode">#</a> <code>zstd_decode</code></h3>
<p>Decompress Zstandard-compressed data and return the original bytes. Dies if the input is not valid Zstandard. This is the inverse of <code>zstd</code>. Use it to read <code>.zst</code> files or decompress cached buffers that were compressed with <code>zstd</code>.</p>
<pre><code class="lang-perl">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"))
</code></pre>
</article>
<article class="doc-entry" id="doc-sha3-256">
<h3><a class="doc-anchor" href="#doc-sha3-256">#</a> <code>sha3_256</code></h3>
<p><code>sha3_256</code> (alias <code>s3_256</code>) 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>
<pre><code class="lang-perl">p sha3_256 "hello world" # 644bcc7e...
my $h = s3_256(slurp "file.bin")
</code></pre>
</article>
<article class="doc-entry" id="doc-sha3-512">
<h3><a class="doc-anchor" href="#doc-sha3-512">#</a> <code>sha3_512</code></h3>
<p><code>sha3_512</code> (alias <code>s3_512</code>) computes the SHA3-512 hash and returns a 128-character hex string. Provides a 512-bit digest with the SHA-3 sponge construction.</p>
<pre><code class="lang-perl">p sha3_512 "hello world" # 840006...
</code></pre>
</article>
<article class="doc-entry" id="doc-shake128">
<h3><a class="doc-anchor" href="#doc-shake128">#</a> <code>shake128</code></h3>
<p><code>shake128</code> 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>
<pre><code class="lang-perl">p shake128("seed", 32) # 64 hex chars (32 bytes)
p shake128("seed", 64) # 128 hex chars
</code></pre>
</article>
<article class="doc-entry" id="doc-shake256">
<h3><a class="doc-anchor" href="#doc-shake256">#</a> <code>shake256</code></h3>
<p><code>shake256</code> is a SHA-3 XOF with higher security margin than SHAKE128. Takes data and output length in bytes, returns hex.</p>
<pre><code class="lang-perl">p shake256("seed", 32)
p shake256("key material", 64)
</code></pre>
</article>
<article class="doc-entry" id="doc-ripemd160">
<h3><a class="doc-anchor" href="#doc-ripemd160">#</a> <code>ripemd160</code></h3>
<p><code>ripemd160</code> (alias <code>rmd160</code>) 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>
<pre><code class="lang-perl">p ripemd160 "hello world" # 98c615784c...
my $hash160 = ripemd160(hex_decode(sha256($pubkey)))
</code></pre>
</article>
<article class="doc-entry" id="doc-siphash">
<h3><a class="doc-anchor" href="#doc-siphash">#</a> <code>siphash</code></h3>
<p><code>siphash</code> 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>
<pre><code class="lang-perl">p siphash "key" # 16 hex chars
</code></pre>
</article>
<article class="doc-entry" id="doc-hmac-sha1">
<h3><a class="doc-anchor" href="#doc-hmac-sha1">#</a> <code>hmac_sha1</code></h3>
<p><code>hmac_sha1</code> 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>
<pre><code class="lang-perl">p hmac_sha1("secret", "message") # 40 hex chars
</code></pre>
</article>
<article class="doc-entry" id="doc-hmac-sha384">
<h3><a class="doc-anchor" href="#doc-hmac-sha384">#</a> <code>hmac_sha384</code></h3>
<p><code>hmac_sha384</code> computes HMAC-SHA384 and returns a 96-character hex string. Middle ground between SHA-256 and SHA-512.</p>
<pre><code class="lang-perl">p hmac_sha384("key", "data") # 96 hex chars
</code></pre>
</article>
<article class="doc-entry" id="doc-hmac-sha512">
<h3><a class="doc-anchor" href="#doc-hmac-sha512">#</a> <code>hmac_sha512</code></h3>
<p><code>hmac_sha512</code> computes HMAC-SHA512 and returns a 128-character hex string. Maximum security margin in the SHA-2 family.</p>
<pre><code class="lang-perl">p hmac_sha512("key", "data") # 128 hex chars
</code></pre>
</article>
<article class="doc-entry" id="doc-hmac-md5">
<h3><a class="doc-anchor" href="#doc-hmac-md5">#</a> <code>hmac_md5</code></h3>
<p><code>hmac_md5</code> 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>
<pre><code class="lang-perl">p hmac_md5("key", "data") # 32 hex chars
</code></pre>
</article>
<article class="doc-entry" id="doc-hkdf-sha256">
<h3><a class="doc-anchor" href="#doc-hkdf-sha256">#</a> <code>hkdf_sha256</code></h3>
<p><code>hkdf_sha256</code> (alias <code>hkdf</code>) 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.</p>
<pre><code class="lang-perl">my $key = hkdf("shared_secret", "salt", "context", 32) # 64 hex
my $enc_key = hex_decode($key) # 32 bytes for AES-256
</code></pre>
</article>
<article class="doc-entry" id="doc-hkdf-sha512">
<h3><a class="doc-anchor" href="#doc-hkdf-sha512">#</a> <code>hkdf_sha512</code></h3>
<p><code>hkdf_sha512</code> is HKDF using HMAC-SHA512. Higher security margin than SHA256 variant.</p>
<pre><code class="lang-perl">my $key = hkdf_sha512("ikm", "salt", "info", 64) # 128 hex chars
</code></pre>
</article>
<article class="doc-entry" id="doc-poly1305">
<h3><a class="doc-anchor" href="#doc-poly1305">#</a> <code>poly1305</code></h3>
<p><code>poly1305</code> 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.</p>
<pre><code class="lang-perl">my $key = random_bytes(32)
p poly1305($key, "message") # 32 hex chars
</code></pre>
</article>
<article class="doc-entry" id="doc-rsa-keygen">
<h3><a class="doc-anchor" href="#doc-rsa-keygen">#</a> <code>rsa_keygen</code></h3>
<p><code>rsa_keygen</code> 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.</p>
<pre><code class="lang-perl">my @kp = rsa_keygen(2048)
my ($priv, $pub) = @kp
spurt("private.pem", $priv)
spurt("public.pem", $pub)
</code></pre>
</article>
<article class="doc-entry" id="doc-rsa-encrypt">
<h3><a class="doc-anchor" href="#doc-rsa-encrypt">#</a> <code>rsa_encrypt</code></h3>
<p><code>rsa_encrypt</code> (alias <code>rsa_enc</code>) 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).</p>
<pre><code class="lang-perl">my $cipher = rsa_encrypt($pub_pem, "secret")
my $plain = rsa_decrypt($priv_pem, $cipher)
</code></pre>
</article>
<article class="doc-entry" id="doc-rsa-decrypt">
<h3><a class="doc-anchor" href="#doc-rsa-decrypt">#</a> <code>rsa_decrypt</code></h3>
<p><code>rsa_decrypt</code> (alias <code>rsa_dec</code>) decrypts RSA-OAEP ciphertext. Takes private_key_pem and base64 ciphertext.</p>
<pre><code class="lang-perl">my $plain = rsa_decrypt($priv, $ciphertext)
p $plain
</code></pre>
</article>
<article class="doc-entry" id="doc-rsa-sign">
<h3><a class="doc-anchor" href="#doc-rsa-sign">#</a> <code>rsa_sign</code></h3>
<p><code>rsa_sign</code> signs a message with RSA-PKCS1v15-SHA256. Takes private_key_pem and message. Returns base64 signature. This is the RS256 algorithm used in JWT.</p>
<pre><code class="lang-perl">my $sig = rsa_sign($priv, "message")
if (rsa_verify($pub, "message", $sig)) {
p "valid"
}
</code></pre>
</article>
<article class="doc-entry" id="doc-rsa-verify">
<h3><a class="doc-anchor" href="#doc-rsa-verify">#</a> <code>rsa_verify</code></h3>
<p><code>rsa_verify</code> verifies an RSA-PKCS1v15-SHA256 signature. Takes public_key_pem, message, and base64 signature. Returns 1 if valid, 0 if not.</p>
<pre><code class="lang-perl">if (rsa_verify($pub_pem, $msg, $sig)) {
p "signature valid"
}
</code></pre>
</article>
<article class="doc-entry" id="doc-ecdsa-p256-keygen">
<h3><a class="doc-anchor" href="#doc-ecdsa-p256-keygen">#</a> <code>ecdsa_p256_keygen</code></h3>
<p><code>ecdsa_p256_keygen</code> (alias <code>p256_keygen</code>) 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.</p>
<pre><code class="lang-perl">my @kp = ecdsa_p256_keygen()
my ($priv, $pub) = @kp
</code></pre>
</article>
<article class="doc-entry" id="doc-ecdsa-p256-sign">
<h3><a class="doc-anchor" href="#doc-ecdsa-p256-sign">#</a> <code>ecdsa_p256_sign</code></h3>
<p><code>ecdsa_p256_sign</code> (alias <code>p256_sign</code>) signs a message with ECDSA P-256. Takes private_key_hex and message. Returns DER-encoded signature as hex.</p>
<pre><code class="lang-perl">my $sig = ecdsa_p256_sign($priv, "hello")
</code></pre>
</article>
<article class="doc-entry" id="doc-ecdsa-p256-verify">
<h3><a class="doc-anchor" href="#doc-ecdsa-p256-verify">#</a> <code>ecdsa_p256_verify</code></h3>
<p><code>ecdsa_p256_verify</code> (alias <code>p256_verify</code>) verifies an ECDSA P-256 signature. Returns 1 if valid.</p>
<pre><code class="lang-perl">if (ecdsa_p256_verify($pub, "hello", $sig)) {
p "valid"
}
</code></pre>
</article>
<article class="doc-entry" id="doc-ecdsa-p384-keygen">
<h3><a class="doc-anchor" href="#doc-ecdsa-p384-keygen">#</a> <code>ecdsa_p384_keygen</code></h3>
<p><code>ecdsa_p384_keygen</code> generates an ECDSA P-384 keypair. P-384 offers more security margin than P-256.</p>
<pre><code class="lang-perl">my @kp = ecdsa_p384_keygen()
</code></pre>
</article>
<article class="doc-entry" id="doc-ecdsa-p384-sign">
<h3><a class="doc-anchor" href="#doc-ecdsa-p384-sign">#</a> <code>ecdsa_p384_sign</code></h3>
<p><code>ecdsa_p384_sign</code> signs with ECDSA P-384.</p>
<pre><code class="lang-perl">my $sig = ecdsa_p384_sign($priv, $msg)
</code></pre>
</article>
<article class="doc-entry" id="doc-ecdsa-p384-verify">
<h3><a class="doc-anchor" href="#doc-ecdsa-p384-verify">#</a> <code>ecdsa_p384_verify</code></h3>
<p><code>ecdsa_p384_verify</code> verifies an ECDSA P-384 signature.</p>
<pre><code class="lang-perl">p ecdsa_p384_verify($pub, $msg, $sig)
</code></pre>
</article>
<article class="doc-entry" id="doc-ecdsa-secp256k1-keygen">
<h3><a class="doc-anchor" href="#doc-ecdsa-secp256k1-keygen">#</a> <code>ecdsa_secp256k1_keygen</code></h3>
<p><code>ecdsa_secp256k1_keygen</code> generates an ECDSA secp256k1 keypair. This is the Bitcoin/Ethereum curve — different from P-256.</p>
<pre><code class="lang-perl">my @kp = ecdsa_secp256k1_keygen()
</code></pre>
</article>
<article class="doc-entry" id="doc-ecdsa-secp256k1-sign">
<h3><a class="doc-anchor" href="#doc-ecdsa-secp256k1-sign">#</a> <code>ecdsa_secp256k1_sign</code></h3>
<p><code>ecdsa_secp256k1_sign</code> signs with ECDSA secp256k1.</p>
<pre><code class="lang-perl">my $sig = ecdsa_secp256k1_sign($priv, $msg)
</code></pre>
</article>
<article class="doc-entry" id="doc-ecdsa-secp256k1-verify">
<h3><a class="doc-anchor" href="#doc-ecdsa-secp256k1-verify">#</a> <code>ecdsa_secp256k1_verify</code></h3>
<p><code>ecdsa_secp256k1_verify</code> verifies an ECDSA secp256k1 signature.</p>
<pre><code class="lang-perl">p ecdsa_secp256k1_verify($pub, $msg, $sig)
</code></pre>
</article>
<article class="doc-entry" id="doc-ecdh-p256">
<h3><a class="doc-anchor" href="#doc-ecdh-p256">#</a> <code>ecdh_p256</code></h3>
<p><code>ecdh_p256</code> (alias <code>p256_dh</code>) 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.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-ecdh-p384">
<h3><a class="doc-anchor" href="#doc-ecdh-p384">#</a> <code>ecdh_p384</code></h3>
<p><code>ecdh_p384</code> performs ECDH key exchange on P-384.</p>
<pre><code class="lang-perl">my $shared = ecdh_p384($my_priv, $their_pub)
</code></pre>
</article>
<article class="doc-entry" id="doc-base32-encode">
<h3><a class="doc-anchor" href="#doc-base32-encode">#</a> <code>base32_encode</code></h3>
<p><code>base32_encode</code> (alias <code>b32e</code>) encodes data as RFC 4648 Base32. Used in TOTP secrets, onion addresses, and Bech32. Returns uppercase with padding.</p>
<pre><code class="lang-perl">p base32_encode("hello") # NBSWY3DP
my $secret = base32_encode(random_bytes(20))
</code></pre>
</article>
<article class="doc-entry" id="doc-base32-decode">
<h3><a class="doc-anchor" href="#doc-base32-decode">#</a> <code>base32_decode</code></h3>
<p><code>base32_decode</code> (alias <code>b32d</code>) decodes RFC 4648 Base32 back to bytes. Accepts with or without padding.</p>
<pre><code class="lang-perl">p base32_decode("NBSWY3DP") # hello
</code></pre>
</article>
<article class="doc-entry" id="doc-base58-encode">
<h3><a class="doc-anchor" href="#doc-base58-encode">#</a> <code>base58_encode</code></h3>
<p><code>base58_encode</code> (alias <code>b58e</code>) encodes data using Bitcoin's Base58 alphabet (no 0, O, I, l to avoid confusion). Used in Bitcoin addresses, IPFS CIDs.</p>
<pre><code class="lang-perl">p base58_encode("hello") # Cn8eVZg
</code></pre>
</article>
<article class="doc-entry" id="doc-base58-decode">
<h3><a class="doc-anchor" href="#doc-base58-decode">#</a> <code>base58_decode</code></h3>
<p><code>base58_decode</code> (alias <code>b58d</code>) decodes Base58 back to bytes.</p>
<pre><code class="lang-perl">p base58_decode("Cn8eVZg") # hello
</code></pre>
</article>
<article class="doc-entry" id="doc-totp">
<h3><a class="doc-anchor" href="#doc-totp">#</a> <code>totp</code></h3>
<p><code>totp</code> (alias <code>totp_generate</code>) 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.</p>
<pre><code class="lang-perl">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)
</code></pre>
</article>
<article class="doc-entry" id="doc-totp-verify">
<h3><a class="doc-anchor" href="#doc-totp-verify">#</a> <code>totp_verify</code></h3>
<p><code>totp_verify</code> verifies a TOTP code with optional time window (default ±1 period). Returns 1 if valid.</p>
<pre><code class="lang-perl">if (totp_verify($secret, $user_code)) {
p "2FA valid"
}
# Wider window: ±2 periods
totp_verify($secret, $code, 2)
</code></pre>
</article>
<article class="doc-entry" id="doc-hotp">
<h3><a class="doc-anchor" href="#doc-hotp">#</a> <code>hotp</code></h3>
<p><code>hotp</code> (alias <code>hotp_generate</code>) generates an HOTP code (RFC 4226) using a counter. Takes base32 secret, counter value, optional digits.</p>
<pre><code class="lang-perl">my $code = hotp($secret, 42) # counter=42
</code></pre>
</article>
<article class="doc-entry" id="doc-aes-cbc-encrypt">
<h3><a class="doc-anchor" href="#doc-aes-cbc-encrypt">#</a> <code>aes_cbc_encrypt</code></h3>
<p><code>aes_cbc_encrypt</code> (alias <code>aes_cbc_enc</code>) 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 <code>aes_encrypt</code> (GCM) for new code.</p>
<pre><code class="lang-perl">my $key = random_bytes(32)
my $ct = aes_cbc_encrypt($key, "secret")
my $pt = aes_cbc_decrypt($key, $ct)
</code></pre>
</article>
<article class="doc-entry" id="doc-aes-cbc-decrypt">
<h3><a class="doc-anchor" href="#doc-aes-cbc-decrypt">#</a> <code>aes_cbc_decrypt</code></h3>
<p><code>aes_cbc_decrypt</code> (alias <code>aes_cbc_dec</code>) decrypts AES-256-CBC. Takes 32-byte key and base64(iv || ciphertext).</p>
<pre><code class="lang-perl">my $pt = aes_cbc_decrypt($key, $ciphertext)
</code></pre>
</article>
<article class="doc-entry" id="doc-qr-ascii">
<h3><a class="doc-anchor" href="#doc-qr-ascii">#</a> <code>qr_ascii</code></h3>
<p><code>qr_ascii</code> (alias <code>qr</code>) generates a QR code as ASCII art. Perfect for terminal output.</p>
<pre><code class="lang-perl">p qr("https://example.com")
p qr("otpauth://totp/App:user?secret=$secret&issuer=App")
</code></pre>
</article>
<article class="doc-entry" id="doc-qr-png">
<h3><a class="doc-anchor" href="#doc-qr-png">#</a> <code>qr_png</code></h3>
<p><code>qr_png</code> generates a QR code as PNG image data (base64 encoded). Optional size parameter. Save to file or embed in HTML.</p>
<pre><code class="lang-perl">my $png = qr_png("https://example.com")
spurt("qr.png", base64_decode($png))
# Larger QR
my $big = qr_png($url, 16)
</code></pre>
</article>
<article class="doc-entry" id="doc-qr-svg">
<h3><a class="doc-anchor" href="#doc-qr-svg">#</a> <code>qr_svg</code></h3>
<p><code>qr_svg</code> generates a QR code as SVG string. Scalable vector graphics, ideal for web.</p>
<pre><code class="lang-perl">my $svg = qr_svg("https://example.com")
spurt("qr.svg", $svg)
</code></pre>
</article>
<article class="doc-entry" id="doc-barcode-code128">
<h3><a class="doc-anchor" href="#doc-barcode-code128">#</a> <code>barcode_code128</code></h3>
<p><code>barcode_code128</code> (alias <code>code128</code>) generates a Code 128 barcode as ASCII. Code 128 supports alphanumeric data and is widely used in shipping labels.</p>
<pre><code class="lang-perl">p code128("ABC-123")
</code></pre>
</article>
<article class="doc-entry" id="doc-barcode-code39">
<h3><a class="doc-anchor" href="#doc-barcode-code39">#</a> <code>barcode_code39</code></h3>
<p><code>barcode_code39</code> (alias <code>code39</code>) generates a Code 39 barcode. Supports uppercase, digits, and some symbols. Used in automotive and defense.</p>
<pre><code class="lang-perl">p code39("HELLO123")
</code></pre>
</article>
<article class="doc-entry" id="doc-barcode-ean13">
<h3><a class="doc-anchor" href="#doc-barcode-ean13">#</a> <code>barcode_ean13</code></h3>
<p><code>barcode_ean13</code> (alias <code>ean13</code>) generates an EAN-13 barcode (European Article Number). Standard retail barcode — requires exactly 12-13 digits.</p>
<pre><code class="lang-perl">p ean13("5901234123457")
</code></pre>
</article>
<article class="doc-entry" id="doc-barcode-svg">
<h3><a class="doc-anchor" href="#doc-barcode-svg">#</a> <code>barcode_svg</code></h3>
<p><code>barcode_svg</code> generates a barcode as SVG. Second argument specifies type: code128, code39, ean13, upca.</p>
<pre><code class="lang-perl">my $svg = barcode_svg("ABC-123", "code128")
spurt("barcode.svg", $svg)
my $retail = barcode_svg("012345678905", "upca")
</code></pre>
</article>
<article class="doc-entry" id="doc-brotli">
<h3><a class="doc-anchor" href="#doc-brotli">#</a> <code>brotli</code></h3>
<p><code>brotli</code> (alias <code>br</code>) compresses data using the Brotli algorithm (RFC 7932). Excellent compression ratio, used in HTTP compression. Returns compressed bytes.</p>
<pre><code class="lang-perl">my $compressed = brotli($data)
p length($data) . " -> " . length($compressed)
</code></pre>
</article>
<article class="doc-entry" id="doc-brotli-decode">
<h3><a class="doc-anchor" href="#doc-brotli-decode">#</a> <code>brotli_decode</code></h3>
<p><code>brotli_decode</code> (alias <code>ubr</code>) decompresses Brotli data.</p>
<pre><code class="lang-perl">my $original = brotli_decode($compressed)
</code></pre>
</article>
<article class="doc-entry" id="doc-xz">
<h3><a class="doc-anchor" href="#doc-xz">#</a> <code>xz</code></h3>
<p><code>xz</code> (alias <code>lzma</code>) compresses data using XZ/LZMA2. Best compression ratio, slower. Returns compressed bytes.</p>
<pre><code class="lang-perl">my $compressed = xz($data)
spurt("file.xz", $compressed)
</code></pre>
</article>
<article class="doc-entry" id="doc-xz-decode">
<h3><a class="doc-anchor" href="#doc-xz-decode">#</a> <code>xz_decode</code></h3>
<p><code>xz_decode</code> (aliases <code>unxz</code>, <code>unlzma</code>) decompresses XZ/LZMA data.</p>
<pre><code class="lang-perl">my $original = xz_decode(slurp("file.xz"))
</code></pre>
</article>
<article class="doc-entry" id="doc-bzip2">
<h3><a class="doc-anchor" href="#doc-bzip2">#</a> <code>bzip2</code></h3>
<p><code>bzip2</code> (alias <code>bz2</code>) compresses data using bzip2. Good compression, moderate speed. Returns compressed bytes.</p>
<pre><code class="lang-perl">my $compressed = bzip2($data)
</code></pre>
</article>
<article class="doc-entry" id="doc-bzip2-decode">
<h3><a class="doc-anchor" href="#doc-bzip2-decode">#</a> <code>bzip2_decode</code></h3>
<p><code>bzip2_decode</code> (aliases <code>bunzip2</code>, <code>ubz2</code>) decompresses bzip2 data.</p>
<pre><code class="lang-perl">my $original = bunzip2($compressed)
</code></pre>
</article>
<article class="doc-entry" id="doc-lz4">
<h3><a class="doc-anchor" href="#doc-lz4">#</a> <code>lz4</code></h3>
<p><code>lz4</code> compresses data using LZ4. Very fast compression/decompression, moderate ratio. Ideal for real-time compression.</p>
<pre><code class="lang-perl">my $compressed = lz4($data)
</code></pre>
</article>
<article class="doc-entry" id="doc-lz4-decode">
<h3><a class="doc-anchor" href="#doc-lz4-decode">#</a> <code>lz4_decode</code></h3>
<p><code>lz4_decode</code> (alias <code>unlz4</code>) decompresses LZ4 data.</p>
<pre><code class="lang-perl">my $original = lz4_decode($compressed)
</code></pre>
</article>
<article class="doc-entry" id="doc-snappy">
<h3><a class="doc-anchor" href="#doc-snappy">#</a> <code>snappy</code></h3>
<p><code>snappy</code> (alias <code>snp</code>) compresses data using Snappy. Fastest compression, used in databases and RPC. Returns compressed bytes.</p>
<pre><code class="lang-perl">my $compressed = snappy($data)
</code></pre>
</article>
<article class="doc-entry" id="doc-snappy-decode">
<h3><a class="doc-anchor" href="#doc-snappy-decode">#</a> <code>snappy_decode</code></h3>
<p><code>snappy_decode</code> (alias <code>unsnappy</code>) decompresses Snappy data.</p>
<pre><code class="lang-perl">my $original = snappy_decode($compressed)
</code></pre>
</article>
<article class="doc-entry" id="doc-lzw">
<h3><a class="doc-anchor" href="#doc-lzw">#</a> <code>lzw</code></h3>
<p><code>lzw</code> compresses data using LZW (GIF/TIFF style). Classic algorithm.</p>
<pre><code class="lang-perl">my $compressed = lzw($data)
</code></pre>
</article>
<article class="doc-entry" id="doc-lzw-decode">
<h3><a class="doc-anchor" href="#doc-lzw-decode">#</a> <code>lzw_decode</code></h3>
<p><code>lzw_decode</code> (alias <code>unlzw</code>) decompresses LZW data.</p>
<pre><code class="lang-perl">my $original = lzw_decode($compressed)
</code></pre>
</article>
<article class="doc-entry" id="doc-tar-create">
<h3><a class="doc-anchor" href="#doc-tar-create">#</a> <code>tar_create</code></h3>
<p><code>tar_create</code> (alias <code>tar</code>) creates a tar archive from a directory. Returns tar bytes.</p>
<pre><code class="lang-perl">my $archive = tar_create("./src")
spurt("backup.tar", $archive)
</code></pre>
</article>
<article class="doc-entry" id="doc-tar-extract">
<h3><a class="doc-anchor" href="#doc-tar-extract">#</a> <code>tar_extract</code></h3>
<p><code>tar_extract</code> (alias <code>untar</code>) extracts a tar archive to a directory.</p>
<pre><code class="lang-perl">tar_extract(slurp("backup.tar"), "./restored")
</code></pre>
</article>
<article class="doc-entry" id="doc-tar-list">
<h3><a class="doc-anchor" href="#doc-tar-list">#</a> <code>tar_list</code></h3>
<p><code>tar_list</code> lists files in a tar archive. Returns array of paths.</p>
<pre><code class="lang-perl">my @files = @{tar_list(slurp("backup.tar"))}
@files |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-tar-gz-create">
<h3><a class="doc-anchor" href="#doc-tar-gz-create">#</a> <code>tar_gz_create</code></h3>
<p><code>tar_gz_create</code> (alias <code>tgz</code>) creates a gzipped tar archive. Convenience for tar + gzip.</p>
<pre><code class="lang-perl">my $tgz = tgz("./project")
spurt("project.tar.gz", $tgz)
</code></pre>
</article>
<article class="doc-entry" id="doc-tar-gz-extract">
<h3><a class="doc-anchor" href="#doc-tar-gz-extract">#</a> <code>tar_gz_extract</code></h3>
<p><code>tar_gz_extract</code> (alias <code>untgz</code>) extracts a .tar.gz archive.</p>
<pre><code class="lang-perl">untgz(slurp("project.tar.gz"), "./extracted")
</code></pre>
</article>
<article class="doc-entry" id="doc-zip-create">
<h3><a class="doc-anchor" href="#doc-zip-create">#</a> <code>zip_create</code></h3>
<p><code>zip_create</code> creates a ZIP archive from a directory. Returns zip bytes.</p>
<pre><code class="lang-perl">my $archive = zip_create("./docs")
spurt("docs.zip", $archive)
</code></pre>
</article>
<article class="doc-entry" id="doc-zip-extract">
<h3><a class="doc-anchor" href="#doc-zip-extract">#</a> <code>zip_extract</code></h3>
<p><code>zip_extract</code> extracts a ZIP archive to a directory.</p>
<pre><code class="lang-perl">zip_extract(slurp("docs.zip"), "./extracted")
</code></pre>
</article>
<article class="doc-entry" id="doc-zip-list">
<h3><a class="doc-anchor" href="#doc-zip-list">#</a> <code>zip_list</code></h3>
<p><code>zip_list</code> lists files in a ZIP archive. Returns array of paths.</p>
<pre><code class="lang-perl">my @files = @{zip_list(slurp("archive.zip"))}
</code></pre>
</article>
<article class="doc-entry" id="doc-md4">
<h3><a class="doc-anchor" href="#doc-md4">#</a> <code>md4</code></h3>
<p><code>md4</code> 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>
<pre><code class="lang-perl">p md4("hello") # 32 hex chars
</code></pre>
</article>
<article class="doc-entry" id="doc-xxh32">
<h3><a class="doc-anchor" href="#doc-xxh32">#</a> <code>xxh32</code></h3>
<p><code>xxh32</code> (alias <code>xxhash32</code>) computes xxHash32 — extremely fast non-cryptographic hash. Optional seed parameter. Returns 8 hex chars.</p>
<pre><code class="lang-perl">p xxh32("hello") # default seed 0
p xxh32("hello", 42) # with seed
</code></pre>
</article>
<article class="doc-entry" id="doc-xxh64">
<h3><a class="doc-anchor" href="#doc-xxh64">#</a> <code>xxh64</code></h3>
<p><code>xxh64</code> (alias <code>xxhash64</code>) computes xxHash64 — fast 64-bit hash. Returns 16 hex chars.</p>
<pre><code class="lang-perl">p xxh64("hello")
</code></pre>
</article>
<article class="doc-entry" id="doc-xxh3">
<h3><a class="doc-anchor" href="#doc-xxh3">#</a> <code>xxh3</code></h3>
<p><code>xxh3</code> (alias <code>xxhash3</code>) computes xxHash3-64 — newest xxHash variant, fastest on modern CPUs. Returns 16 hex chars.</p>
<pre><code class="lang-perl">p xxh3("hello")
</code></pre>
</article>
<article class="doc-entry" id="doc-xxh3-128">
<h3><a class="doc-anchor" href="#doc-xxh3-128">#</a> <code>xxh3_128</code></h3>
<p><code>xxh3_128</code> computes xxHash3-128. Returns 32 hex chars.</p>
<pre><code class="lang-perl">p xxh3_128("hello")
</code></pre>
</article>
<article class="doc-entry" id="doc-murmur3">
<h3><a class="doc-anchor" href="#doc-murmur3">#</a> <code>murmur3</code></h3>
<p><code>murmur3</code> (alias <code>murmur3_32</code>) computes MurmurHash3 32-bit. Fast non-cryptographic hash, widely used in hash tables and bloom filters. Optional seed. Returns 8 hex chars.</p>
<pre><code class="lang-perl">p murmur3("hello") # default seed 0
p murmur3("hello", 42) # with seed
</code></pre>
</article>
<article class="doc-entry" id="doc-murmur3-128">
<h3><a class="doc-anchor" href="#doc-murmur3-128">#</a> <code>murmur3_128</code></h3>
<p><code>murmur3_128</code> computes MurmurHash3 128-bit (x64 variant). Returns 32 hex chars.</p>
<pre><code class="lang-perl">p murmur3_128("hello")
</code></pre>
</article>
<article class="doc-entry" id="doc-blowfish-encrypt">
<h3><a class="doc-anchor" href="#doc-blowfish-encrypt">#</a> <code>blowfish_encrypt</code></h3>
<p><code>blowfish_encrypt</code> (alias <code>bf_enc</code>) encrypts with Blowfish-CBC. Key=4-56 bytes, optional 8-byte IV. Legacy cipher — use AES for new code.</p>
<pre><code class="lang-perl">my $ct = blowfish_encrypt($key, "secret")
my $pt = blowfish_decrypt($key, $ct)
</code></pre>
</article>
<article class="doc-entry" id="doc-blowfish-decrypt">
<h3><a class="doc-anchor" href="#doc-blowfish-decrypt">#</a> <code>blowfish_decrypt</code></h3>
<p><code>blowfish_decrypt</code> (alias <code>bf_dec</code>) decrypts Blowfish-CBC.</p>
<pre><code class="lang-perl">my $pt = blowfish_decrypt($key, $ciphertext)
</code></pre>
</article>
<article class="doc-entry" id="doc-des3-encrypt">
<h3><a class="doc-anchor" href="#doc-des3-encrypt">#</a> <code>des3_encrypt</code></h3>
<p><code>des3_encrypt</code> (aliases <code>3des_enc</code>, <code>tdes_enc</code>) encrypts with Triple DES (3DES) CBC. Key=24 bytes (three 8-byte DES keys). Legacy cipher for PCI-DSS compliance.</p>
<pre><code class="lang-perl">my $key = random_bytes(24)
my $ct = des3_encrypt($key, "secret")
my $pt = des3_decrypt($key, $ct)
</code></pre>
</article>
<article class="doc-entry" id="doc-des3-decrypt">
<h3><a class="doc-anchor" href="#doc-des3-decrypt">#</a> <code>des3_decrypt</code></h3>
<p><code>des3_decrypt</code> (aliases <code>3des_dec</code>, <code>tdes_dec</code>) decrypts Triple DES (3DES) CBC.</p>
<pre><code class="lang-perl">my $pt = des3_decrypt($key, $ciphertext)
</code></pre>
</article>
<article class="doc-entry" id="doc-twofish-encrypt">
<h3><a class="doc-anchor" href="#doc-twofish-encrypt">#</a> <code>twofish_encrypt</code></h3>
<p><code>twofish_encrypt</code> (alias <code>tf_enc</code>) encrypts with Twofish-CBC. Key=16/24/32 bytes. AES finalist, still secure.</p>
<pre><code class="lang-perl">my $key = random_bytes(32)
my $ct = twofish_encrypt($key, "secret")
</code></pre>
</article>
<article class="doc-entry" id="doc-twofish-decrypt">
<h3><a class="doc-anchor" href="#doc-twofish-decrypt">#</a> <code>twofish_decrypt</code></h3>
<p><code>twofish_decrypt</code> (alias <code>tf_dec</code>) decrypts Twofish-CBC.</p>
<pre><code class="lang-perl">my $pt = twofish_decrypt($key, $ct)
</code></pre>
</article>
<article class="doc-entry" id="doc-camellia-encrypt">
<h3><a class="doc-anchor" href="#doc-camellia-encrypt">#</a> <code>camellia_encrypt</code></h3>
<p><code>camellia_encrypt</code> (alias <code>cam_enc</code>) encrypts with Camellia-CBC. Key=16/24/32 bytes. Japanese/EU standard, equivalent security to AES.</p>
<pre><code class="lang-perl">my $ct = camellia_encrypt($key, "secret")
</code></pre>
</article>
<article class="doc-entry" id="doc-camellia-decrypt">
<h3><a class="doc-anchor" href="#doc-camellia-decrypt">#</a> <code>camellia_decrypt</code></h3>
<p><code>camellia_decrypt</code> (alias <code>cam_dec</code>) decrypts Camellia-CBC.</p>
<pre><code class="lang-perl">my $pt = camellia_decrypt($key, $ct)
</code></pre>
</article>
<article class="doc-entry" id="doc-cast5-encrypt">
<h3><a class="doc-anchor" href="#doc-cast5-encrypt">#</a> <code>cast5_encrypt</code></h3>
<p><code>cast5_encrypt</code> encrypts with CAST5-CBC. Key=5-16 bytes. Used in PGP.</p>
<pre><code class="lang-perl">my $ct = cast5_encrypt($key, "secret")
</code></pre>
</article>
<article class="doc-entry" id="doc-cast5-decrypt">
<h3><a class="doc-anchor" href="#doc-cast5-decrypt">#</a> <code>cast5_decrypt</code></h3>
<p><code>cast5_decrypt</code> decrypts CAST5-CBC.</p>
<pre><code class="lang-perl">my $pt = cast5_decrypt($key, $ct)
</code></pre>
</article>
<article class="doc-entry" id="doc-salsa20">
<h3><a class="doc-anchor" href="#doc-salsa20">#</a> <code>salsa20</code></h3>
<p><code>salsa20</code> encrypts with Salsa20 stream cipher. Key=32 bytes, nonce auto-generated. Fast, secure stream cipher.</p>
<pre><code class="lang-perl">my $ct = salsa20($key, "data")
my $pt = salsa20_decrypt($key, $ct)
</code></pre>
</article>
<article class="doc-entry" id="doc-salsa20-decrypt">
<h3><a class="doc-anchor" href="#doc-salsa20-decrypt">#</a> <code>salsa20_decrypt</code></h3>
<p><code>salsa20_decrypt</code> decrypts Salsa20.</p>
<pre><code class="lang-perl">my $pt = salsa20_decrypt($key, $ct)
</code></pre>
</article>
<article class="doc-entry" id="doc-xsalsa20">
<h3><a class="doc-anchor" href="#doc-xsalsa20">#</a> <code>xsalsa20</code></h3>
<p><code>xsalsa20</code> encrypts with XSalsa20 (extended 24-byte nonce). Safer for random nonces.</p>
<pre><code class="lang-perl">my $ct = xsalsa20($key, "data")
</code></pre>
</article>
<article class="doc-entry" id="doc-xsalsa20-decrypt">
<h3><a class="doc-anchor" href="#doc-xsalsa20-decrypt">#</a> <code>xsalsa20_decrypt</code></h3>
<p><code>xsalsa20_decrypt</code> decrypts XSalsa20.</p>
<pre><code class="lang-perl">my $pt = xsalsa20_decrypt($key, $ct)
</code></pre>
</article>
<article class="doc-entry" id="doc-secretbox">
<h3><a class="doc-anchor" href="#doc-secretbox">#</a> <code>secretbox</code></h3>
<p><code>secretbox</code> (alias <code>secretbox_seal</code>) is NaCl's symmetric authenticated encryption (XSalsa20-Poly1305). Key=32 bytes. Simple, secure, fast.</p>
<pre><code class="lang-perl">my $key = random_bytes(32)
my $ct = secretbox($key, "message")
my $pt = secretbox_open($key, $ct)
</code></pre>
</article>
<article class="doc-entry" id="doc-secretbox-open">
<h3><a class="doc-anchor" href="#doc-secretbox-open">#</a> <code>secretbox_open</code></h3>
<p><code>secretbox_open</code> decrypts and authenticates NaCl secretbox.</p>
<pre><code class="lang-perl">my $pt = secretbox_open($key, $ct)
</code></pre>
</article>
<article class="doc-entry" id="doc-nacl-box-keygen">
<h3><a class="doc-anchor" href="#doc-nacl-box-keygen">#</a> <code>nacl_box_keygen</code></h3>
<p><code>nacl_box_keygen</code> generates a NaCl box keypair (X25519). Returns [secret_key_hex, public_key_hex].</p>
<pre><code class="lang-perl">my @kp = nacl_box_keygen()
my ($sk, $pk) = @kp
</code></pre>
</article>
<article class="doc-entry" id="doc-nacl-box">
<h3><a class="doc-anchor" href="#doc-nacl-box">#</a> <code>nacl_box</code></h3>
<p><code>nacl_box</code> is NaCl's asymmetric authenticated encryption. Takes recipient's public key, sender's secret key, plaintext.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-nacl-box-open">
<h3><a class="doc-anchor" href="#doc-nacl-box-open">#</a> <code>nacl_box_open</code></h3>
<p><code>nacl_box_open</code> decrypts NaCl box. Takes sender's public key, recipient's secret key, ciphertext.</p>
<pre><code class="lang-perl">my $pt = nacl_box_open($sender_pk, $my_sk, $ct)
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-special-math-functions">
<h2>Special Math Functions</h2>
<p class="chapter-meta">12 topics</p>
<article class="doc-entry" id="doc-erf">
<h3><a class="doc-anchor" href="#doc-erf">#</a> <code>erf</code></h3>
<p><code>erf</code> 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>
<pre><code class="lang-perl">p erf(0) # 0
p erf(1) # 0.8427...
p erf(10) # ~1
</code></pre>
</article>
<article class="doc-entry" id="doc-erfc">
<h3><a class="doc-anchor" href="#doc-erfc">#</a> <code>erfc</code></h3>
<p><code>erfc</code> 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>
<pre><code class="lang-perl">p erfc(0) # 1
p erfc(3) # 0.0000220...
</code></pre>
</article>
<article class="doc-entry" id="doc-gamma">
<h3><a class="doc-anchor" href="#doc-gamma">#</a> <code>gamma</code></h3>
<p><code>gamma</code> (alias <code>tgamma</code>) 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>
<pre><code class="lang-perl">p gamma(5) # 24 (= 4!)
p gamma(0.5) # √π ≈ 1.7724...
p gamma(1) # 1
</code></pre>
</article>
<article class="doc-entry" id="doc-lgamma">
<h3><a class="doc-anchor" href="#doc-lgamma">#</a> <code>lgamma</code></h3>
<p><code>lgamma</code> (alias <code>ln_gamma</code>) 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>
<pre><code class="lang-perl">p lgamma(100) # 359.13...
p lgamma(1000) # 5905.22...
</code></pre>
</article>
<article class="doc-entry" id="doc-digamma">
<h3><a class="doc-anchor" href="#doc-digamma">#</a> <code>digamma</code></h3>
<p><code>digamma</code> (alias <code>psi</code>) 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>
<pre><code class="lang-perl">p digamma(1) # -γ ≈ -0.5772 (Euler-Mascheroni)
p digamma(2) # 1 - γ ≈ 0.4228
</code></pre>
</article>
<article class="doc-entry" id="doc-beta-fn">
<h3><a class="doc-anchor" href="#doc-beta-fn">#</a> <code>beta_fn</code></h3>
<p><code>beta_fn</code> 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>
<pre><code class="lang-perl">p beta_fn(2, 3) # 0.0833...
p beta_fn(0.5, 0.5) # π
</code></pre>
</article>
<article class="doc-entry" id="doc-lbeta">
<h3><a class="doc-anchor" href="#doc-lbeta">#</a> <code>lbeta</code></h3>
<p><code>lbeta</code> (alias <code>ln_beta</code>) 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>
<pre><code class="lang-perl">p lbeta(0.01, 0.01) # large positive
</code></pre>
</article>
<article class="doc-entry" id="doc-betainc">
<h3><a class="doc-anchor" href="#doc-betainc">#</a> <code>betainc</code></h3>
<p><code>betainc</code> (alias <code>beta_reg</code>) 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>
<pre><code class="lang-perl">p betainc(0.5, 2, 3) # P(Beta(2,3) < 0.5)
</code></pre>
</article>
<article class="doc-entry" id="doc-gammainc">
<h3><a class="doc-anchor" href="#doc-gammainc">#</a> <code>gammainc</code></h3>
<p><code>gammainc</code> (alias <code>gamma_li</code>) 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>
<pre><code class="lang-perl">p gammainc(2, 1) # γ(2, 1)
</code></pre>
</article>
<article class="doc-entry" id="doc-gammaincc">
<h3><a class="doc-anchor" href="#doc-gammaincc">#</a> <code>gammaincc</code></h3>
<p><code>gammaincc</code> (alias <code>gamma_ui</code>) computes the upper incomplete gamma function Γ(a,x) = ∫ₓ^∞ t^(a-1) e^(-t) dt = Γ(a) - γ(a,x). Useful for tail probabilities.</p>
<pre><code class="lang-perl">p gammaincc(2, 1) # Γ(2, 1)
</code></pre>
</article>
<article class="doc-entry" id="doc-gammainc-reg">
<h3><a class="doc-anchor" href="#doc-gammainc-reg">#</a> <code>gammainc_reg</code></h3>
<p><code>gammainc_reg</code> (alias <code>gamma_lr</code>) computes the regularized lower incomplete gamma P(a,x) = γ(a,x)/Γ(a), the CDF of the gamma distribution Gamma(a, 1).</p>
<pre><code class="lang-perl">p gammainc_reg(2, 1) # P(Gamma(2,1) < 1)
</code></pre>
</article>
<article class="doc-entry" id="doc-gammaincc-reg">
<h3><a class="doc-anchor" href="#doc-gammaincc-reg">#</a> <code>gammaincc_reg</code></h3>
<p><code>gammaincc_reg</code> (alias <code>gamma_ur</code>) computes the regularized upper incomplete gamma Q(a,x) = 1 - P(a,x), the survival function of the gamma distribution.</p>
<pre><code class="lang-perl">p gammaincc_reg(2, 1) # P(Gamma(2,1) > 1)
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-parallel-i-o">
<h2>Parallel I/O</h2>
<p class="chapter-meta">8 topics</p>
<article class="doc-entry" id="doc-par-lines">
<h3><a class="doc-anchor" href="#doc-par-lines">#</a> <code>par_lines</code></h3>
<p><code>par_lines PATH, { code }</code> — memory-map a file and scan its lines in parallel across all available CPU cores.</p>
<p>The file is <code>mmap</code>'d into memory rather than read sequentially, and line boundaries are detected in parallel chunks. Each line is passed to the callback as <code>$_</code>. Because the file is memory-mapped, there is no read-buffer overhead and the OS kernel pages data in on demand, making <code>par_lines</code> 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 <code>pchannel</code>, write to a file, etc.) or use <code>par_lines</code> with a reducer. For ordered processing, use <code>read_lines</code> with <code>pmap</code> instead.</p>
<pre><code class="lang-perl">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 }
</code></pre>
</article>
<article class="doc-entry" id="doc-par-walk">
<h3><a class="doc-anchor" href="#doc-par-walk">#</a> <code>par_walk</code></h3>
<p><code>par_walk PATH, { code }</code> — recursively walk a directory tree in parallel, invoking the callback for every file path found.</p>
<p>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 <code>$_</code> (absolute). This is significantly faster than a sequential <code>find</code>-style walk on SSDs and networked filesystems where directory <code>readdir</code> 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 <code>dirs => 1</code>. Combine with <code>pmap</code> for a two-phase pattern: first collect paths with <code>par_walk</code>, then process file contents in parallel.</p>
<pre><code class="lang-perl">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
}
}
</code></pre>
</article>
<article class="doc-entry" id="doc-par-sed">
<h3><a class="doc-anchor" href="#doc-par-sed">#</a> <code>par_sed</code></h3>
<p><code>par_sed PATTERN, REPLACEMENT, @files</code> — perform an in-place regex substitution across multiple files in parallel.</p>
<p>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 <code>sed -i</code> 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.</p>
<pre><code class="lang-perl">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"
</code></pre>
</article>
<article class="doc-entry" id="doc-par-find-files">
<h3><a class="doc-anchor" href="#doc-par-find-files">#</a> <code>par_find_files</code></h3>
<p>Recursively search a directory tree in parallel for files matching a glob pattern. Unlike <code>glob_par</code> which takes a single pattern string, <code>par_find_files</code> 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.</p>
<pre><code class="lang-perl">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")
</code></pre>
</article>
<article class="doc-entry" id="doc-par-line-count">
<h3><a class="doc-anchor" href="#doc-par-line-count">#</a> <code>par_line_count</code></h3>
<p>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 <code>wc -l</code> for large file sets. Useful for codebase metrics, log analysis, or validating data pipeline output.</p>
<pre><code class="lang-perl">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"
</code></pre>
</article>
<article class="doc-entry" id="doc-par-csv-read">
<h3><a class="doc-anchor" href="#doc-par-csv-read">#</a> <code>par_csv_read</code></h3>
<p><code>par_csv_read @files</code> — read multiple CSV files in parallel, returning an array of parsed datasets (one per file).</p>
<p>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 <code>par_lines</code> with manual splitting, since <code>par_csv_read</code> parallelizes across files, not within a single file.</p>
<pre><code class="lang-perl">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" }
</code></pre>
</article>
<article class="doc-entry" id="doc-glob-par">
<h3><a class="doc-anchor" href="#doc-glob-par">#</a> <code>glob_par</code></h3>
<p>Perform a parallel recursive file-system glob, using multiple threads to walk directory trees concurrently. This is significantly faster than <code>glob</code> for deep directory hierarchies with thousands of files. Accepts the same glob syntax (<code>*</code>, <code>**</code>, <code>{a,b}</code>) but returns results as they are discovered across threads. Ideal for large codebases or log directories.</p>
<pre><code class="lang-perl">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($_) }
</code></pre>
</article>
<article class="doc-entry" id="doc-pwatch">
<h3><a class="doc-anchor" href="#doc-pwatch">#</a> <code>pwatch</code></h3>
<p><code>pwatch(PATH, fn { ... })</code> — watch a file or directory for filesystem changes and invoke the callback on each event.</p>
<p>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 <code>$_</code>. 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 <code>debounce</code> or a <code>pchannel</code> if the callback is expensive and rapid bursts of events need to be coalesced.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-file-i-o">
<h2>File I/O</h2>
<p class="chapter-meta">35 topics</p>
<article class="doc-entry" id="doc-open">
<h3><a class="doc-anchor" href="#doc-open">#</a> <code>open</code></h3>
<p>Open a filehandle for reading, writing, appending, or piping. The three-argument form <code>open my $fh, MODE, EXPR</code> is strongly preferred for safety — it prevents shell injection and makes the mode explicit. Modes include <code><</code> (read), <code>></code> (write/truncate), <code>>></code> (append), <code>+<</code> (read-write), <code>|-</code> (pipe to command), and <code>-|</code> (pipe from command). In stryke, always use lexical filehandles (<code>my $fh</code>) rather than bareword globals. PerlIO layers can be specified in the mode: <code><:utf8</code>, <code><:raw</code>, <code><:encoding(UTF-16)</code>. Always check the return value — <code>open ... or die "...: $!"</code> is idiomatic. The <code>$!</code> variable contains the OS error message on failure. Forgetting to check <code>open</code> is one of the most common bugs in Perl code.</p>
<pre><code class="lang-perl">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 $_ }
</code></pre>
</article>
<article class="doc-entry" id="doc-close">
<h3><a class="doc-anchor" href="#doc-close">#</a> <code>close</code></h3>
<p>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, <code>close</code> is where buffered data actually hits disk, so a full disk or network error may only surface at <code>close</code> time. Always check the return value when writing: <code>close $fh or die "close: $!"</code>. For pipe handles opened with <code>|-</code> or <code>-|</code>, <code>close</code> waits for the child process to exit and sets <code>$?</code> to the child's exit status. In stryke, lexical filehandles are automatically closed when they go out of scope, but explicit <code>close</code> is clearer and lets you handle errors.</p>
<pre><code class="lang-perl">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 $?
</code></pre>
</article>
<article class="doc-entry" id="doc-read">
<h3><a class="doc-anchor" href="#doc-read">#</a> <code>read</code></h3>
<p>Read a specified number of bytes from a filehandle into a scalar buffer. The signature is <code>read FH, SCALAR, LENGTH [, OFFSET]</code>. Returns the number of bytes actually read (which may be less than requested at EOF or on partial reads), 0 at EOF, or <code>undef</code> 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 <code><:raw</code> for binary data to avoid encoding transforms. In stryke, <code>read</code> works identically to Perl 5. For line-oriented input, prefer <code><$fh></code> or <code>readline</code> instead.</p>
<pre><code class="lang-perl">open my $fh, '<:raw', $path or die $!
my $buf = ''
while (read $fh, my $chunk, 4096) {
$buf .= $chunk
}
p "total: " . length($buf) . " bytes"
close $fh
</code></pre>
</article>
<article class="doc-entry" id="doc-readline">
<h3><a class="doc-anchor" href="#doc-readline">#</a> <code>readline</code></h3>
<p>Read one line (or all remaining lines in list context) from a filehandle. The angle-bracket operator <code><$fh></code> is syntactic sugar for <code>readline($fh)</code>. In scalar context, returns the next line including the trailing newline (or <code>undef</code> at EOF). In list context, returns all remaining lines as a list. The line ending is determined by <code>$/</code> (input record separator, default <code>\n</code>). Set <code>$/ = undef</code> to slurp the entire file in one read. In stryke, <code>readline</code> integrates with the pipe operator — you can pipe filehandle lines through <code>maps</code>, <code>greps</code>, and other streaming combinators. Always <code>chomp</code> after reading if you don't want trailing newlines.</p>
<pre><code class="lang-perl">while (my $line = <$fh>) {
chomp $line
p $line
}
# Slurp entire file
local $/
my $content = <$fh>
p length $content
</code></pre>
</article>
<article class="doc-entry" id="doc-eof">
<h3><a class="doc-anchor" href="#doc-eof">#</a> <code>eof</code></h3>
<p>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, <code>eof()</code> (with parens) checks the last file in the <code><></code> / <code>ARGV</code> stream. Called with no parens as <code>eof</code>, it tests whether the current ARGV file is exhausted but more files may follow. In stryke, <code>eof</code> is typically used in <code>until</code> loops or as a guard before <code>read</code> calls. Note that <code>eof</code> 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, <code>while (<$fh>)</code> is simpler and implicitly handles EOF.</p>
<pre><code class="lang-perl">until (eof $fh) {
my $line = <$fh>
p tm $line
}
# Process multiple files via ARGV
while (<>) {
p "new file: $ARGV" if eof()
}
</code></pre>
</article>
<article class="doc-entry" id="doc-seek">
<h3><a class="doc-anchor" href="#doc-seek">#</a> <code>seek</code></h3>
<p>Reposition a filehandle to an arbitrary byte offset. The signature is <code>seek FH, POSITION, WHENCE</code> where WHENCE is 0 (absolute from start), 1 (relative to current position), or 2 (relative to end of file). Use the <code>Fcntl</code> constants <code>SEEK_SET</code>, <code>SEEK_CUR</code>, <code>SEEK_END</code> for clarity. Returns 1 on success, 0 on failure. <code>seek</code> 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, <code>seek</code> flushes the PerlIO buffer before repositioning. Do not mix <code>seek</code>/<code>tell</code> with <code>sysread</code>/<code>syswrite</code> — they use separate buffering layers.</p>
<pre><code class="lang-perl">seek $fh, 0, 0 # rewind to start
my $header = <$fh>
seek $fh, -100, 2 # last 100 bytes
read $fh, my $tail, 100
p $tail
</code></pre>
</article>
<article class="doc-entry" id="doc-tell">
<h3><a class="doc-anchor" href="#doc-tell">#</a> <code>tell</code></h3>
<p>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 <code>seek</code> back if the data doesn't match expectations. In stryke, <code>tell</code> reflects the PerlIO buffered position, not the raw OS file descriptor position — so it correctly accounts for encoding layers and buffered reads. Pair with <code>seek</code> for random-access patterns.</p>
<pre><code class="lang-perl">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
}
</code></pre>
</article>
<article class="doc-entry" id="doc-print">
<h3><a class="doc-anchor" href="#doc-print">#</a> <code>print</code></h3>
<p>Write operands to the selected output handle (default <code>STDOUT</code>) without appending a newline. The output field separator <code>$,</code> is inserted between arguments, and <code>$\</code> 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: <code>print STDERR "msg"</code>. In stryke, <code>print</code> 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 <code>p</code> (say) instead since it handles the newline automatically.</p>
<pre><code class="lang-perl">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"
</code></pre>
</article>
<article class="doc-entry" id="doc-say">
<h3><a class="doc-anchor" href="#doc-say">#</a> <code>say</code></h3>
<p>Print operands followed by an automatic newline to <code>STDOUT</code>. In stryke, <code>say</code> is always available without <code>-E</code> or <code>use feature 'say'</code> — it is a first-class builtin. The shorthand <code>p</code> is an alias for <code>say</code> and is preferred in most stryke code. When given a list, <code>say</code> joins elements with <code>$,</code> (output field separator, empty by default) and appends <code>$\</code> plus a newline. For streaming output over pipelines, combine with <code>e</code> (each) to print one element per line. Gotcha: <code>say</code> always adds a newline — if you need raw output without one, use <code>print</code> instead.</p>
<pre><code class="lang-perl">p "hello world"
my @names = ("alice", "bob", "eve")
@names |> e p
1..5 |> maps { $_ * 2 } |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-printf">
<h3><a class="doc-anchor" href="#doc-printf">#</a> <code>printf</code></h3>
<p>Formatted print to a filehandle (default <code>STDOUT</code>), using C-style format specifiers. The first argument is the format string with <code>%s</code> (string), <code>%d</code> (integer), <code>%f</code> (float), <code>%x</code> (hex), <code>%o</code> (octal), <code>%e</code> (scientific), <code>%g</code> (general float), and <code>%%</code> (literal percent). Width and precision modifiers work as in C: <code>%-10s</code> left-aligns in a 10-char field, <code>%05d</code> zero-pads to 5 digits, <code>%.2f</code> gives 2 decimal places. In stryke, <code>printf</code> supports all standard Perl 5 format specifiers including <code>%v</code> (version strings) and <code>%n</code> is disabled for safety. Direct output to a handle by placing it before the format: <code>printf STDERR "...", @args</code>. Unlike <code>sprintf</code>, <code>printf</code> outputs directly and returns a boolean indicating success.</p>
<pre><code class="lang-perl">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"
</code></pre>
</article>
<article class="doc-entry" id="doc-sprintf">
<h3><a class="doc-anchor" href="#doc-sprintf">#</a> <code>sprintf</code></h3>
<p>Return a formatted string without printing it, using the same C-style format specifiers as <code>printf</code>. 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, <code>sprintf</code> is often combined with the pipe operator: <code>$val |> t { sprintf "0x%04x", $_ } |> p</code>. The return value is always a string. All format specifiers from <code>printf</code> apply here.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-slurp">
<h3><a class="doc-anchor" href="#doc-slurp">#</a> <code>slurp</code></h3>
<p>Read an entire file into memory as a single UTF-8 string. The short alias <code>sl</code> is convenient in pipelines. Dies if the file does not exist or cannot be read. This is the complement of <code>spurt</code>/<code>wf</code> — together they form a simple read/write pair for whole-file operations. For binary data, use <code>read_bytes</code>/<code>slurp_raw</code> instead.</p>
<pre><code class="lang-perl">my $text = slurp("config.yaml")
p $text
my $json = sl("data.json")
my $data = decode_json($json)
"README.md" |> sl |> length |> p # character count
</code></pre>
</article>
<article class="doc-entry" id="doc-slurp-raw">
<h3><a class="doc-anchor" href="#doc-slurp-raw">#</a> <code>slurp_raw</code></h3>
<p>Read an entire file into memory as raw bytes without any encoding interpretation. Unlike <code>slurp</code>, which returns a decoded UTF-8 string, <code>read_bytes</code> preserves the exact byte content — useful for binary files like images, compressed archives, or protocol buffers. The alias <code>slurp_raw</code> emphasizes the raw nature.</p>
<pre><code class="lang-perl">my $png = read_bytes("logo.png")
p length($png) # byte count
my $gz = slurp_raw("data.gz")
my $text = gunzip($gz)
p $text
</code></pre>
</article>
<article class="doc-entry" id="doc-input">
<h3><a class="doc-anchor" href="#doc-input">#</a> <code>input</code></h3>
<p>Slurp all of stdin (or a filehandle) as one string.</p>
<pre><code class="lang-perl">my $all = input # slurp stdin
my $fh_data = input($fh) # slurp filehandle
</code></pre>
</article>
<article class="doc-entry" id="doc-read-lines">
<h3><a class="doc-anchor" href="#doc-read-lines">#</a> <code>read_lines</code></h3>
<p>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 <code>rl</code> keeps one-liners concise. If the file does not exist, the program dies with an error message.</p>
<pre><code class="lang-perl">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.
</code></pre>
</article>
<article class="doc-entry" id="doc-append-file">
<h3><a class="doc-anchor" href="#doc-append-file">#</a> <code>append_file</code></h3>
<p>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 <code>af</code> is convenient in pipelines. The file is opened, written, and closed atomically per call.</p>
<pre><code class="lang-perl">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" }
</code></pre>
</article>
<article class="doc-entry" id="doc-to-file">
<h3><a class="doc-anchor" href="#doc-to-file">#</a> <code>to_file</code></h3>
<p>Write a string to a file, truncating any existing content. Unlike <code>append_file</code>, 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.</p>
<pre><code class="lang-perl">my $csv = "name,age\nAlice,30\nBob,25"
$csv |> to_file("people.csv") |> p
to_file("empty.txt", "") # truncate a file
</code></pre>
<p>Note: the return-value-for-piping behavior distinguishes this from a plain write.</p>
</article>
<article class="doc-entry" id="doc-write">
<h3><a class="doc-anchor" href="#doc-write">#</a> <code>write</code></h3>
<p>Output a formatted record to a filehandle using a <code>format</code> declaration. <code>write</code> 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 <code>Text::Table</code> and template engines. In stryke, <code>write</code> and <code>format</code> are supported for backward compatibility but are rarely used in new code — <code>printf</code>/<code>sprintf</code> or template strings are more flexible. The format name defaults to the filehandle name (e.g., format <code>STDOUT</code> is used by <code>write STDOUT</code>).</p>
<pre><code class="lang-perl">format STDOUT =
@<<<<<<<<<< @>>>>>>
$name, $score
.
my ($name, $score) = ("alice", 42)
write # outputs: alice 42
</code></pre>
</article>
<article class="doc-entry" id="doc-write-file">
<h3><a class="doc-anchor" href="#doc-write-file">#</a> <code>write_file</code></h3>
<p>Write a string to a file, creating it if it does not exist or truncating it if it does. This is the complement of <code>slurp</code> — together they form a read/write pair for whole-file operations. The short alias <code>wf</code> is convenient for one-liners. The file is opened, written, and closed in a single call.</p>
<pre><code class="lang-perl">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)
</code></pre>
</article>
<article class="doc-entry" id="doc-write-json">
<h3><a class="doc-anchor" href="#doc-write-json">#</a> <code>write_json</code></h3>
<p>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 <code>wj</code> pairs with <code>rj</code> for round-trip JSON workflows. Useful for persisting configuration, caching API responses, or generating fixture data.</p>
<pre><code class="lang-perl">my %data = (name => "Alice", scores => [98, 87, 95])
wj("out.json", \%data)
my $back = rj("out.json")
p $back->{name} # Alice
</code></pre>
</article>
<article class="doc-entry" id="doc-read-json">
<h3><a class="doc-anchor" href="#doc-read-json">#</a> <code>read_json</code></h3>
<p>Read a JSON file from disk and parse it into a stryke data structure (hash ref or array ref). The short alias <code>rj</code> keeps JSON-config one-liners terse. Dies if the file does not exist or contains malformed JSON. This is the complement of <code>write_json</code>/<code>wj</code>.</p>
<pre><code class="lang-perl">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.
</code></pre>
</article>
<article class="doc-entry" id="doc-tempfile">
<h3><a class="doc-anchor" href="#doc-tempfile">#</a> <code>tempfile</code></h3>
<p>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 <code>tf</code> 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.</p>
<pre><code class="lang-perl">my $tmp = tf()
to_file($tmp, "scratch data\n")
p rl($tmp) # scratch data
my @all = map { tf() } 1..3 # three temp files
</code></pre>
</article>
<article class="doc-entry" id="doc-tempdir">
<h3><a class="doc-anchor" href="#doc-tempdir">#</a> <code>tempdir</code></h3>
<p>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 <code>tdr</code> mirrors <code>tf</code> for files. Useful for isolating multi-file operations like test fixtures, build artifacts, or staged output.</p>
<pre><code class="lang-perl">my $dir = tdr()
to_file("$dir/a.txt", "hello")
to_file("$dir/b.txt", "world")
my @files = glob("$dir/*.txt")
p scalar @files # 2
</code></pre>
</article>
<article class="doc-entry" id="doc-binmode">
<h3><a class="doc-anchor" href="#doc-binmode">#</a> <code>binmode</code></h3>
<p>Set the I/O layer on a filehandle, controlling how bytes are translated during reads and writes. Without a layer argument, <code>binmode $fh</code> switches the handle to raw binary mode (no CRLF translation on Windows, no encoding transforms). With a layer, <code>binmode $fh, ':utf8'</code> enables UTF-8 decoding, <code>binmode $fh, ':raw'</code> strips all layers for pure byte I/O, and <code>binmode $fh, ':encoding(ISO-8859-1)'</code> sets a specific encoding. In stryke, encoding layers can also be specified directly in <code>open</code>: <code>open my $fh, '<:utf8', $path</code>. Call <code>binmode</code> 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 <code>:raw</code>.</p>
<pre><code class="lang-perl">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)
</code></pre>
</article>
<article class="doc-entry" id="doc-fileno">
<h3><a class="doc-anchor" href="#doc-fileno">#</a> <code>fileno</code></h3>
<p>Return the underlying OS file descriptor number for a filehandle, or <code>undef</code> 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, <code>fileno</code> is rarely needed in everyday code but is essential for low-level I/O multiplexing and process management.</p>
<pre><code class="lang-perl">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"
}
</code></pre>
</article>
<article class="doc-entry" id="doc-flock">
<h3><a class="doc-anchor" href="#doc-flock">#</a> <code>flock</code></h3>
<p>Advisory file locking for coordinating access between processes. <code>flock $fh, OPERATION</code> where OPERATION is <code>LOCK_SH</code> (shared/read lock), <code>LOCK_EX</code> (exclusive/write lock), or <code>LOCK_UN</code> (unlock). Add <code>LOCK_NB</code> for non-blocking mode: <code>LOCK_EX | LOCK_NB</code> returns false immediately if the lock is held rather than waiting. Import constants from <code>Fcntl</code>. Advisory locks are cooperative — they only work if all processes accessing the file use <code>flock</code>. In stryke, <code>flock</code> 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: <code>flock</code> does not work on NFS on many systems.</p>
<pre><code class="lang-perl">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"
}
</code></pre>
</article>
<article class="doc-entry" id="doc-getc">
<h3><a class="doc-anchor" href="#doc-getc">#</a> <code>getc</code></h3>
<p>Read a single character from a filehandle (default <code>STDIN</code>). Returns <code>undef</code> at EOF. The character returned respects the handle's encoding layer — under <code>:utf8</code>, <code>getc</code> 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, <code>getc</code> blocks until a character is available on the handle. For terminal input, note that most terminals are line-buffered by default, so <code>getc STDIN</code> won't return until the user presses Enter unless you put the terminal into raw mode.</p>
<pre><code class="lang-perl">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) . ")"
}
</code></pre>
</article>
<article class="doc-entry" id="doc-select">
<h3><a class="doc-anchor" href="#doc-select">#</a> <code>select</code></h3>
<p>In its one-argument form, <code>select HANDLE</code> sets the default output handle for <code>print</code>, <code>say</code>, and <code>write</code>, 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, <code>select RBITS, WBITS, EBITS, TIMEOUT</code> performs POSIX <code>select(2)</code> 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 <code>IO::Select</code> or async I/O patterns for multiplexing. <code>select</code> with <code>$|</code> is also the classic way to enable autoflush on a handle.</p>
<pre><code class="lang-perl">my $old = select STDERR
p "this goes to stderr"
select $old
# Enable autoflush on STDOUT
select STDOUT; $| = 1
print "immediately flushed"
</code></pre>
</article>
<article class="doc-entry" id="doc-truncate">
<h3><a class="doc-anchor" href="#doc-truncate">#</a> <code>truncate</code></h3>
<p>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. <code>truncate $fh, 0</code> empties the file entirely — a common pattern when rewriting a file in place. <code>truncate $fh, $len</code> discards everything beyond byte <code>$len</code>. Returns true on success, false on failure (check <code>$!</code> for the error). In stryke, truncate works on any seekable filehandle. When using truncate to rewrite a file, remember to also <code>seek $fh, 0, 0</code> to rewind the write position — truncating does not move the file pointer. Gotcha: truncating a file opened read-only will fail.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-sysopen">
<h3><a class="doc-anchor" href="#doc-sysopen">#</a> <code>sysopen</code></h3>
<p>Low-level open using POSIX flags for precise control over how a file is opened. The signature is <code>sysopen FH, FILENAME, FLAGS [, PERMS]</code>. Flags are bitwise-OR combinations from <code>Fcntl</code>: <code>O_RDONLY</code>, <code>O_WRONLY</code>, <code>O_RDWR</code>, <code>O_CREAT</code>, <code>O_EXCL</code>, <code>O_TRUNC</code>, <code>O_APPEND</code>, <code>O_NONBLOCK</code>, and others. The optional PERMS argument (e.g., <code>0644</code>) sets the file mode when <code>O_CREAT</code> creates a new file, subject to the process umask. <code>sysopen</code> is the right tool when you need <code>O_EXCL</code> for atomic file creation (lock files, temp files), <code>O_NONBLOCK</code> for non-blocking I/O, or other flags that <code>open</code> cannot express. In stryke, prefer three-argument <code>open</code> for routine file access and reserve <code>sysopen</code> for cases requiring specific POSIX semantics.</p>
<pre><code class="lang-perl">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: $!"
</code></pre>
</article>
<article class="doc-entry" id="doc-sysread">
<h3><a class="doc-anchor" href="#doc-sysread">#</a> <code>sysread</code></h3>
<p>Low-level unbuffered read directly from a file descriptor, bypassing PerlIO buffering layers. The signature is <code>sysread FH, SCALAR, LENGTH [, OFFSET]</code>. Returns the number of bytes read, 0 at EOF, or <code>undef</code> on error. Unlike <code>read</code>, <code>sysread</code> issues a single <code>read(2)</code> 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 <code>sysread</code>/<code>syswrite</code> with buffered I/O (<code>print</code>, <code>read</code>, <code><$fh></code>) on the same handle — the buffered and unbuffered positions will diverge and produce corrupted reads.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-syswrite">
<h3><a class="doc-anchor" href="#doc-syswrite">#</a> <code>syswrite</code></h3>
<p>Low-level unbuffered write directly to a file descriptor, bypassing PerlIO buffering layers. The signature is <code>syswrite FH, SCALAR [, LENGTH [, OFFSET]]</code>. 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 <code>undef</code> on error. Like <code>sysread</code>, this issues a single <code>write(2)</code> system call and must not be mixed with buffered I/O on the same handle. In stryke, <code>syswrite</code> 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.</p>
<pre><code class="lang-perl">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
}
</code></pre>
</article>
<article class="doc-entry" id="doc-sysseek">
<h3><a class="doc-anchor" href="#doc-sysseek">#</a> <code>sysseek</code></h3>
<p>Low-level seek on a file descriptor, bypassing PerlIO buffering. The signature is <code>sysseek FH, POSITION, WHENCE</code> with the same WHENCE values as <code>seek</code> (0=start, 1=current, 2=end). Returns the new position as a true value, or <code>undef</code> on failure. Unlike <code>seek</code>, <code>sysseek</code> does not flush PerlIO buffers — it operates directly on the underlying OS file descriptor. Use <code>sysseek</code> when working with <code>sysread</code>/<code>syswrite</code> for consistent positioning. In stryke, <code>sysseek</code> with <code>SEEK_CUR</code> and position 0 is an idiom for querying the current fd position without moving: <code>my $pos = sysseek $fh, 0, 1</code>.</p>
<pre><code class="lang-perl">sysseek $fh, 0, 0 # rewind to start
sysread $fh, my $buf, 512
my $pos = sysseek $fh, 0, 1
p "fd position: $pos"
</code></pre>
</article>
<article class="doc-entry" id="doc-format">
<h3><a class="doc-anchor" href="#doc-format">#</a> <code>format</code></h3>
<p>Declare a picture-format template for generating fixed-width text reports. The syntax is <code>format NAME = ... .</code> where each line alternates between picture lines (containing field placeholders) and argument lines (listing the variables to fill in). Placeholders include <code>@<<<<</code> (left-align), <code>@>>>></code> (right-align), <code>@||||</code> (center), <code>@###.##</code> (numeric with decimal), and <code>@*</code> (multiline block fill). The format ends with a lone <code>.</code> on its own line. In stryke, formats are a legacy feature preserved for compatibility with Perl 5 code — for new reports, prefer <code>printf</code>/<code>sprintf</code> for simple alignment or a templating module for complex layouts. Formats interact with the special variables <code>$~</code> (current format name), <code>$^</code> (header format), and <code>$=</code> (lines per page).</p>
<pre><code class="lang-perl">format REPORT =
@<<<<<<<<<<<<<<<< @>>>>> @ ###.##
$item, $qty, $price
.
my ($item, $qty, $price) = ("Widget", 100, 9.99)
my $old = select REPORT
$~ = 'REPORT'
write REPORT
select $old
</code></pre>
</article>
<article class="doc-entry" id="doc-formline">
<h3><a class="doc-anchor" href="#doc-formline">#</a> <code>formline</code></h3>
<p>Format a line of output according to a picture template, appending the result to the <code>$^A</code> (format accumulator) variable. This is the low-level engine behind Perl's <code>format</code>/<code>write</code> report-generation system. Template characters like <code>@<<<</code> (left-justify), <code>@>>></code> (right-justify), and <code>@###.##</code> (numeric) control field placement.</p>
<pre><code class="lang-perl">$^A = ""
formline("@<<<< @>>>>>\n", "Name", "Score")
formline("@<<<< @>>>>>\n", "Alice", 98)
formline("@<<<< @>>>>>\n", "Bob", 85)
p $^A
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-strings">
<h2>Strings</h2>
<p class="chapter-meta">26 topics</p>
<article class="doc-entry" id="doc-chomp">
<h3><a class="doc-anchor" href="#doc-chomp">#</a> <code>chomp</code></h3>
<p><code>chomp STRING</code> — remove the trailing record separator (usually <code>\n</code>) from a string in place and return the number of characters removed.</p>
<p><code>chomp</code> is the idiomatic way to strip newlines after reading input; unlike <code>chop</code>, it only removes the value of <code>$/</code> (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 <code>chomp</code> an entire array to strip every element at once. In stryke, <code>chomp</code> operates on UTF-8 strings and respects multi-byte <code>$/</code> values. Prefer <code>chomp</code> over <code>chop</code> in virtually all input-processing code; <code>chop</code> is only for when you truly need to remove an arbitrary trailing character regardless of what it is.</p>
<pre><code class="lang-perl">my $line = <STDIN>
chomp $line
p $line
chomp(my @lines = <$fh>) # strip all at once
p scalar @lines
</code></pre>
</article>
<article class="doc-entry" id="doc-chop">
<h3><a class="doc-anchor" href="#doc-chop">#</a> <code>chop</code></h3>
<p><code>chop STRING</code> — remove and return the last character of a string, modifying the string in place.</p>
<p>Unlike <code>chomp</code>, <code>chop</code> 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 <code>chop</code> 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 <code>\n</code>. When called on an array, <code>chop</code> removes the last character of every element and returns the last one removed.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-length">
<h3><a class="doc-anchor" href="#doc-length">#</a> <code>length</code></h3>
<p><code>length STRING</code> — return the number of characters in a string, or the number of elements when given an array.</p>
<p>In string context, <code>length</code> counts Unicode characters, not bytes — so <code>length "\x{1F600}"</code> 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 <code>scalar @arr</code>), which diverges slightly from Perl where <code>length @arr</code> stringifies the array first. This dual behavior is intentional in stryke for convenience. To get byte length instead of character length, use <code>bytes::length</code> or encode first. Always use <code>length</code> rather than comparing against the empty string when checking for non-empty input.</p>
<pre><code class="lang-perl">p length "hello" # 5
my @a = (1..10)
p length @a # 10
p length "\x{1F600}" # 1 (single emoji codepoint)
</code></pre>
</article>
<article class="doc-entry" id="doc-substr">
<h3><a class="doc-anchor" href="#doc-substr">#</a> <code>substr</code></h3>
<p><code>substr STRING, OFFSET [, LENGTH [, REPLACEMENT]]</code> — extract or replace a substring.</p>
<p><code>substr</code> 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 (<code>substr $s, -3</code> gives the last three characters). In stryke, offsets are UTF-8 character positions, making it safe for multi-byte text. <code>substr</code> as an lvalue (<code>substr($s, 0, 1) = "X"</code>) is also supported for in-place mutation. Prefer <code>substr</code> over regex when you know exact positions — it is faster and clearer.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-index">
<h3><a class="doc-anchor" href="#doc-index">#</a> <code>index</code></h3>
<p><code>index STRING, SUBSTRING [, POSITION]</code> — return the zero-based position of the first occurrence of SUBSTRING within STRING, or -1 if not found.</p>
<p>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 <code>index</code> repeatedly, advancing POSITION past each hit). In stryke, <code>index</code> operates on UTF-8 character positions, not byte offsets, so it is safe for multi-byte strings. For finding the *last* occurrence, use <code>rindex</code> instead. A common pattern is pairing <code>index</code> with <code>substr</code> to extract fields from fixed-format data without the overhead of a regex or <code>split</code>.</p>
<pre><code class="lang-perl">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++
}
</code></pre>
</article>
<article class="doc-entry" id="doc-rindex">
<h3><a class="doc-anchor" href="#doc-rindex">#</a> <code>rindex</code></h3>
<p><code>rindex STRING, SUBSTRING [, POSITION]</code> — return the zero-based position of the last occurrence of SUBSTRING within STRING, searching backward from POSITION (or the end).</p>
<p><code>rindex</code> mirrors <code>index</code> 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 <code>substr</code> for efficient right-side extraction without regex.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-split">
<h3><a class="doc-anchor" href="#doc-split">#</a> <code>split</code></h3>
<p><code>split /PATTERN/, STRING [, LIMIT]</code> — divide STRING into a list of substrings by splitting on each occurrence of PATTERN.</p>
<p><code>split</code> 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 <code>" "</code> (a single space string, not regex) mimics <code>awk</code>-style splitting: it strips leading whitespace and splits on runs of whitespace. In stryke, <code>split</code> integrates with <code>|></code> pipelines, accepting piped-in strings for ergonomic one-liners. Trailing empty fields are removed by default; pass -1 as LIMIT to preserve them.</p>
<pre><code class="lang-perl">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"
</code></pre>
</article>
<article class="doc-entry" id="doc-join">
<h3><a class="doc-anchor" href="#doc-join">#</a> <code>join</code></h3>
<p><code>join SEPARATOR, LIST</code> — concatenate all elements of LIST into a single string, placing SEPARATOR between each pair of adjacent elements.</p>
<p><code>join</code> is the inverse of <code>split</code>. It stringifies each element before joining, so mixing numbers and strings is fine. An empty separator (<code>join "", @list</code>) concatenates without gaps. In stryke, <code>join</code> works naturally with <code>|></code> pipelines: a range or filtered list can be piped directly into <code>join</code> with a separator argument. This is the standard way to build CSV lines, path strings, or human-readable lists from arrays. <code>join</code> never adds a trailing separator — if you need one, append it yourself.</p>
<pre><code class="lang-perl">my $csv = join ",", @fields
1..5 |> join "-" |> p # 1-2-3-4-5
my @parts = ("usr", "local", "bin")
p join "/", "", @parts # /usr/local/bin
</code></pre>
</article>
<article class="doc-entry" id="doc-uc">
<h3><a class="doc-anchor" href="#doc-uc">#</a> <code>uc</code></h3>
<p><code>uc STRING</code> — return a fully uppercased copy of the string.</p>
<p><code>uc</code> 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 <code>uc</code> for normalizing strings before comparison, formatting headers, or transforming pipeline output. In stryke <code>|></code> chains, combine with <code>maps</code> or <code>t</code> for streaming uppercase transforms. For uppercasing only the first character (e.g., sentence capitalization), use <code>ucfirst</code> instead.</p>
<pre><code class="lang-perl">p uc "hello" # HELLO
@words |> maps { uc } |> e p
"whisper" |> t uc |> p # WHISPER
</code></pre>
</article>
<article class="doc-entry" id="doc-lc">
<h3><a class="doc-anchor" href="#doc-lc">#</a> <code>lc</code></h3>
<p><code>lc STRING</code> — return a fully lowercased copy of the string.</p>
<p><code>lc</code> performs Unicode-aware lowercasing in stryke, so <code>lc "\x{C4}"</code> (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: <code>if (lc $a eq lc $b)</code>. In stryke <code>|></code> pipelines, wrap <code>lc</code> with <code>t</code> to apply it as a streaming transform. For lowercasing only the first character, use <code>lcfirst</code> instead.</p>
<pre><code class="lang-perl">p lc "HELLO" # hello
"SHOUT" |> t lc |> t rev |> p # tuohs
my @norm = map lc, @words
@norm |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-ucfirst">
<h3><a class="doc-anchor" href="#doc-ucfirst">#</a> <code>ucfirst</code></h3>
<p><code>ucfirst STRING</code> — return a copy of the string with only the first character uppercased, leaving the rest unchanged.</p>
<p>This is the standard way to capitalize the first letter of a word for display, title-casing, or converting camelCase to PascalCase. In stryke, <code>ucfirst</code> 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 <code>uc</code>. A common idiom is <code>ucfirst lc $word</code> to normalize a word to "Title" form.</p>
<pre><code class="lang-perl">p ucfirst "hello" # Hello
p ucfirst lc "hELLO" # Hello
my @titled = map { ucfirst lc } @raw
@titled |> join " " |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lcfirst">
<h3><a class="doc-anchor" href="#doc-lcfirst">#</a> <code>lcfirst</code></h3>
<p><code>lcfirst STRING</code> — return a copy of the string with only the first character lowercased, leaving the rest unchanged.</p>
<p>This is useful for converting PascalCase identifiers to camelCase, or for formatting output where only the initial letter matters. In stryke, <code>lcfirst</code> is Unicode-aware, so it handles accented capitals and multi-byte first characters correctly. Like <code>lc</code>, it returns a new string rather than modifying in place. If you need the entire string lowercased, use <code>lc</code> instead.</p>
<pre><code class="lang-perl">p lcfirst "Hello" # hello
p lcfirst "XMLParser" # xMLParser
my @camel = map lcfirst, @PascalNames
@camel |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-chr">
<h3><a class="doc-anchor" href="#doc-chr">#</a> <code>chr</code></h3>
<p><code>chr NUMBER</code> — return the character represented by the given ASCII or Unicode code point.</p>
<p><code>chr</code> is the inverse of <code>ord</code>: <code>chr(ord($c)) eq $c</code> 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 <code>chr 0x1F600</code> gives you a smiley emoji with no special encoding gymnastics. For string literals, stryke supports all standard escapes: <code>\x{hex}</code>, <code>\u{hex}</code>, <code>\o{oct}</code>, <code>\NNN</code> (octal), <code>\cX</code> (control), <code>\N{U+hex}</code>, <code>\N{UNICODE NAME}</code>, plus case modifiers <code>\U..\E</code>, <code>\L..\E</code>, <code>\u</code>, <code>\l</code>, <code>\Q..\E</code>.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-ord">
<h3><a class="doc-anchor" href="#doc-ord">#</a> <code>ord</code></h3>
<p><code>ord STRING</code> — return the numeric (Unicode code point) value of the first character of the string.</p>
<p><code>ord</code> is the inverse of <code>chr</code>: <code>ord(chr($n)) == $n</code> always holds. When passed a multi-character string, only the first character is examined — the rest are ignored. In stryke, <code>ord</code> returns the full Unicode code point, not just 0-255, so <code>ord "\u{1F600}"</code> returns 128512. This is useful for character classification, building lookup tables, or implementing custom encodings. For ASCII checks, <code>ord($c) >= 32 && ord($c) <= 126</code> tests printability.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-hex">
<h3><a class="doc-anchor" href="#doc-hex">#</a> <code>hex</code></h3>
<p><code>hex STRING</code> — interpret a hexadecimal string and return its numeric value.</p>
<p>The leading <code>0x</code> prefix is optional: both <code>hex "ff"</code> and <code>hex "0xff"</code> return 255. The string is case-insensitive, so <code>hex "DeAdBeEf"</code> 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 <code>sprintf "%x"</code>. Note that <code>hex</code> always returns a number, never a string — arithmetic is immediate.</p>
<pre><code class="lang-perl">my $n = hex "deadbeef"
printf "0x%x = %d\n", $n, $n
p hex "ff" # 255
"cafe" |> t { hex } |> p # 51966
</code></pre>
</article>
<article class="doc-entry" id="doc-oct">
<h3><a class="doc-anchor" href="#doc-oct">#</a> <code>oct</code></h3>
<p><code>oct STRING</code> — interpret an octal, hexadecimal, or binary string and return its numeric value.</p>
<p><code>oct</code> is the multi-base cousin of <code>hex</code>: it auto-detects the base from the prefix. Strings starting with <code>0b</code> are binary, <code>0x</code> are hex, and bare digits or <code>0</code>-prefixed digits are octal. This makes it the go-to for parsing Unix file permissions (<code>oct "0755"</code> gives 493), binary literals, or any string where the radix is embedded in the value. In stryke, <code>oct</code> handles arbitrarily large integers via the same big-number pathway as other arithmetic. A common gotcha: <code>oct "8"</code> warns because 8 is not a valid octal digit — use <code>hex</code> or a bare numeric literal instead.</p>
<pre><code class="lang-perl">p oct "0755" # 493
p oct "0b1010" # 10
p oct "0xff" # 255
my $perms = oct "644"
p sprintf "%04o", $perms # 0644
</code></pre>
</article>
<article class="doc-entry" id="doc-quotemeta">
<h3><a class="doc-anchor" href="#doc-quotemeta">#</a> <code>quotemeta</code></h3>
<p><code>quotemeta STRING</code> — escape all non-alphanumeric characters with backslashes, returning a string safe for interpolation into a regex.</p>
<p>This is essential when building dynamic regexes from user input: without <code>quotemeta</code>, characters like <code>.</code>, <code>*</code>, <code>(</code>, <code>)</code>, <code>[</code>, and <code>\</code> would be interpreted as regex metacharacters, leading to either broken patterns or security vulnerabilities (ReDoS). The equivalent inline syntax is <code>\Q..\E</code> inside a regex. In stryke, <code>quotemeta</code> handles the full Unicode range, escaping any character that is not <code>[A-Za-z0-9_]</code>. Use it liberally whenever you splice user-provided strings into patterns.</p>
<pre><code class="lang-perl">my $input = "file (1).txt"
my $safe = quotemeta $input
p $safe # file\ \(1\)\.txt
my $found = ("file (1).txt" =~ /^$safe$/)
p $found # 1
</code></pre>
</article>
<article class="doc-entry" id="doc-trim">
<h3><a class="doc-anchor" href="#doc-trim">#</a> <code>trim</code></h3>
<p><code>trim STRING</code> or <code>trim LIST</code> — strip leading and trailing ASCII whitespace.</p>
<p>When given a single string, <code>trim</code> 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 <code>tm</code> alias is convenient in pipeline chains where brevity matters.</p>
<pre><code class="lang-perl">" hello " |> tm |> p # "hello"
@raw |> tm |> e p
slurp("data.csv") |> ln |> tm |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-lines">
<h3><a class="doc-anchor" href="#doc-lines">#</a> <code>lines</code></h3>
<p><code>lines STRING</code> / <code>ln STRING</code> — split a string on newline boundaries, returning a streaming iterator of lines.</p>
<p>Each line is yielded without the trailing newline character. When piped from <code>slurp</code>, this gives you a lazy line-by-line view of a file without loading all lines into memory at once. Both <code>\n</code> and <code>\r\n</code> line endings are handled. The <code>ln</code> alias keeps pipelines compact.</p>
<pre><code class="lang-perl">slurp("data.txt") |> lines |> e p
my @rows = lines $multiline_str
$body |> ln |> grep /TODO/ |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-words">
<h3><a class="doc-anchor" href="#doc-words">#</a> <code>words</code></h3>
<p><code>words</code> (alias <code>wd</code>) splits a string on whitespace boundaries and returns the resulting list of words. It handles leading, trailing, and consecutive whitespace gracefully — unlike a naive <code>split / /</code>, it never produces empty strings. This is the idiomatic way to tokenize a line of text in stryke, and the short alias <code>wd</code> keeps pipelines compact. It is equivalent to Perl's <code>split ' '</code> behavior.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-chars">
<h3><a class="doc-anchor" href="#doc-chars">#</a> <code>chars</code></h3>
<p><code>chars STRING</code> / <code>ch STRING</code> — split a string into individual characters, returning a streaming iterator.</p>
<p>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 <code>take</code>, <code>grep</code>, or <code>with_index</code> without materializing the full character array.</p>
<pre><code class="lang-perl">"hello" |> chars |> e p # h e l l o
my @c = chars "abc"
"emoji: \x{1F600}" |> ch |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-snake-case">
<h3><a class="doc-anchor" href="#doc-snake-case">#</a> <code>snake_case</code></h3>
<p><code>snake_case</code> (alias <code>sc</code>) 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., <code>parseHTTPResponse</code> becomes <code>parse_http_response</code>).</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-camel-case">
<h3><a class="doc-anchor" href="#doc-camel-case">#</a> <code>camel_case</code></h3>
<p><code>camel_case</code> (alias <code>cc</code>) 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>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-kebab-case">
<h3><a class="doc-anchor" href="#doc-kebab-case">#</a> <code>kebab_case</code></h3>
<p><code>kebab_case</code> (alias <code>kc</code>) 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 <code>snake_case</code>, it intelligently handles acronyms and mixed-case input. The function treats underscores, spaces, and case transitions as word boundaries.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-study">
<h3><a class="doc-anchor" href="#doc-study">#</a> <code>study</code></h3>
<p><code>study STRING</code> — 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.</p>
<p>In classic Perl, <code>study</code> 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 <code>study</code> 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 <code>study</code> when porting legacy scripts that call it; do not add it to new stryke code expecting a performance benefit.</p>
<pre><code class="lang-perl">study $text # no-op in stryke, kept for compatibility
my @hits = grep { /$pattern/ } @lines
p scalar @hits
</code></pre>
</article>
<article class="doc-entry" id="doc-pos">
<h3><a class="doc-anchor" href="#doc-pos">#</a> <code>pos</code></h3>
<p><code>pos SCALAR</code> — gets or sets the position where the next <code>m//g</code> (global match) will start searching in the given string. After a successful <code>m//g</code> match, <code>pos</code> returns the offset just past the end of the match. You can assign to <code>pos($s)</code> to manually reposition the search. If the last <code>m//g</code> failed, <code>pos</code> resets to <code>undef</code>. This is essential for writing lexers or tokenizers that consume a string incrementally with <code>\G</code>-anchored patterns. In stryke, <code>pos</code> tracks per-scalar state just like Perl.</p>
<pre><code class="lang-perl">my $s = "abcabc"
while ($s =~ /a/g) { p pos($s) }
# 1 4
pos($s) = 0 # reset to scan again
p pos($s) # 0
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-arrays-hashes">
<h2>Arrays & Hashes</h2>
<p class="chapter-meta">19 topics</p>
<article class="doc-entry" id="doc-push">
<h3><a class="doc-anchor" href="#doc-push">#</a> <code>push</code></h3>
<p><code>push @array, LIST</code> — 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, <code>push</code> is O(1) amortized thanks to the underlying Rust <code>Vec</code>.</p>
<pre><code class="lang-perl">my @q
push @q, 1..3
push @q, "four", "five"
p scalar @q # 5
@q |> e p # 1 2 3 four five
</code></pre>
<p>Returns the new element count, so <code>my $len = push @arr, $val;</code> is valid.</p>
</article>
<article class="doc-entry" id="doc-pop">
<h3><a class="doc-anchor" href="#doc-pop">#</a> <code>pop</code></h3>
<p><code>pop @array</code> — removes and returns the last element of an array, or <code>undef</code> if the array is empty. This is the complement of <code>push</code> and together they give you classic stack (LIFO) semantics. In stryke the operation is O(1) because the underlying Rust <code>Vec::pop</code> simply decrements the length. When called without an argument inside a subroutine, <code>pop</code> operates on <code>@_</code>; at file scope it operates on <code>@ARGV</code>, matching standard Perl behavior.</p>
<pre><code class="lang-perl">my @stk = 1..5
my $top = pop @stk
p $top # 5
p scalar @stk # 4
@stk |> e p # 1 2 3 4
</code></pre>
</article>
<article class="doc-entry" id="doc-shift">
<h3><a class="doc-anchor" href="#doc-shift">#</a> <code>shift</code></h3>
<p><code>shift @array</code> — removes and returns the first element of an array, sliding all remaining elements down by one index. Like <code>pop</code>, it returns <code>undef</code> on an empty array. Without an explicit argument it defaults to <code>@_</code> inside subroutines and <code>@ARGV</code> at file scope. Because every element must be moved, <code>shift</code> is O(n); if you only need LIFO access, prefer <code>push</code>/<code>pop</code>. Use <code>shift</code> when processing argument lists or implementing FIFO queues.</p>
<pre><code class="lang-perl">my @args = @ARGV
my $cmd = shift @args
p $cmd
@args |> e p # remaining arguments
</code></pre>
</article>
<article class="doc-entry" id="doc-unshift">
<h3><a class="doc-anchor" href="#doc-unshift">#</a> <code>unshift</code></h3>
<p><code>unshift @array, LIST</code> — prepends one or more elements to the beginning of an array and returns the new length. It is the counterpart of <code>push</code> for the front of the array. Like <code>shift</code>, 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, <code>unshift</code> is the idiomatic choice. You can pass multiple values and they will appear in the same order they were given.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-splice">
<h3><a class="doc-anchor" href="#doc-splice">#</a> <code>splice</code></h3>
<p><code>splice @array, OFFSET [, LENGTH [, LIST]]</code> — 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 <code>Vec::splice</code> and <code>Vec::drain</code>.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-keys">
<h3><a class="doc-anchor" href="#doc-keys">#</a> <code>keys</code></h3>
<p><code>keys %hash</code> — 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 <code>$#array</code>). In scalar context, <code>keys</code> returns the number of keys. Calling <code>keys</code> resets the <code>each</code> iterator on that hash, which is the standard way to restart iteration. In stryke, this calls Rust's <code>HashMap::keys()</code> and collects into a <code>Vec</code>. For sorted output, chain with <code>sort</code> via the pipe operator.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-values">
<h3><a class="doc-anchor" href="#doc-values">#</a> <code>values</code></h3>
<p><code>values %hash</code> — returns the list of all values in a hash in no particular order (matching the order of <code>keys</code> 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 <code>keys</code>, calling <code>values</code> resets the <code>each</code> iterator. In stryke this maps to Rust's <code>HashMap::values()</code>. Combine with <code>sum</code>, <code>sort</code>, or pipeline operators for common aggregation patterns.</p>
<pre><code class="lang-perl">my %scores = (alice => 90, bob => 85)
p sum(values %scores) # 175
values(%scores) |> sort { $_1 <=> $_0 } |> e p # 90 85
</code></pre>
</article>
<article class="doc-entry" id="doc-each">
<h3><a class="doc-anchor" href="#doc-each">#</a> <code>each</code></h3>
<p><code>each %hash</code> — 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 <code>keys</code> or <code>values</code> 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 <code>each</code>; that can cause skipped or duplicated entries. In stryke, the iteration order is non-deterministic (Rust <code>HashMap</code> order).</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-delete">
<h3><a class="doc-anchor" href="#doc-delete">#</a> <code>delete</code></h3>
<p><code>delete EXPR</code> — removes a key-value pair from a hash or an element from an array and returns the removed value (or <code>undef</code> if it did not exist). For hashes this is the only way to truly remove a key; assigning <code>undef</code> to <code>$h{key}</code> leaves the key in place. For arrays, <code>delete</code> sets the element to <code>undef</code> but does not shift indices (use <code>splice</code> if you need to close the gap). In stryke, hash deletion maps to Rust's <code>HashMap::remove</code>. You can delete multiple keys at once with a hash slice: <code>delete @h{@keys}</code>.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-exists">
<h3><a class="doc-anchor" href="#doc-exists">#</a> <code>exists</code></h3>
<p><code>exists EXPR</code> — 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 <code>undef</code>. This is different from <code>defined</code>: a key can exist but hold <code>undef</code>. Use <code>exists</code> to check hash membership before accessing a value to avoid autovivification side effects. In stryke, <code>exists</code> on a hash compiles to Rust's <code>HashMap::contains_key</code>, and on an array it checks bounds. You can also use it with nested structures: <code>exists $h{a}{b}</code> only checks the final level.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-scalar">
<h3><a class="doc-anchor" href="#doc-scalar">#</a> <code>scalar</code></h3>
<p><code>scalar EXPR</code> — forces the expression into scalar context. The most common use is <code>scalar @array</code> to get the element count instead of the list of elements. In stryke, scalar context on an array returns its length as a Rust <code>usize</code>. You can also use <code>scalar</code> 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.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-defined">
<h3><a class="doc-anchor" href="#doc-defined">#</a> <code>defined</code></h3>
<p><code>defined EXPR</code> — returns true if the expression has a value that is not <code>undef</code>. This is the canonical way to distinguish between "no value" and "a value that happens to be false" (such as <code>0</code>, <code>""</code>, or <code>"0"</code>). Use <code>defined</code> before dereferencing optional values or checking return codes from functions that return <code>undef</code> on failure. In stryke, <code>defined</code> compiles to a Rust <code>Option::is_some()</code> check internally. Note that <code>defined</code> on an aggregate (hash or array) is deprecated in Perl 5 and is a no-op in stryke.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-undef">
<h3><a class="doc-anchor" href="#doc-undef">#</a> <code>undef</code></h3>
<p><code>undef</code> — the undefined value, representing the absence of a value. As a function, <code>undef $var</code> explicitly undefines a variable, freeing any value it held. <code>undef</code> is falsy in boolean context and triggers "use of uninitialized value" warnings under <code>use warnings</code>. In stryke, <code>undef</code> maps to Rust's <code>None</code> in an <code>Option</code> type internally. Use <code>undef</code> to reset variables, signal missing return values, or clear hash entries without deleting the key.</p>
<pre><code class="lang-perl">my $x = 42
undef $x
p defined($x) ? "def" : "undef" # undef
fn maybe { return undef if !@_
return $_[0] }
p defined(maybe()) ? "got" : "nothing" # nothing
</code></pre>
</article>
<article class="doc-entry" id="doc-ref">
<h3><a class="doc-anchor" href="#doc-ref">#</a> <code>ref</code></h3>
<p><code>ref EXPR</code> — returns a string indicating the reference type of the value, or an empty string if it is not a reference. Common return values are <code>SCALAR</code>, <code>ARRAY</code>, <code>HASH</code>, <code>CODE</code>, <code>REF</code>, and <code>Regexp</code>. For blessed objects it returns the class name. Use <code>ref</code> to dispatch on data type or validate arguments in polymorphic functions. In stryke, <code>ref</code> inspects the Rust enum variant of the underlying value. Note that <code>ref</code> does not recurse; it only tells you the top-level type.</p>
<pre><code class="lang-perl">my $r = [1, 2, 3]
p ref($r) # ARRAY
p ref(\%ENV) # HASH
p ref(\&main) # CODE
p ref(42) # (empty string)
</code></pre>
</article>
<article class="doc-entry" id="doc-bless">
<h3><a class="doc-anchor" href="#doc-bless">#</a> <code>bless</code></h3>
<p>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 <code>-></code>. The second argument defaults to the current package. This is the foundation of Perl's object system.</p>
<pre><code class="lang-perl">fn new($class, %args) {
bless { %args }, $class
}
my $obj = new("Dog", name => "Rex", breed => "Lab")
p ref($obj) # Dog
p $obj->{name} # Rex
</code></pre>
</article>
<article class="doc-entry" id="doc-tie">
<h3><a class="doc-anchor" href="#doc-tie">#</a> <code>tie</code></h3>
<p>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 <code>untie</code> to remove the binding.</p>
<pre><code class="lang-perl">tie my %db, 'DB_File', 'cache.db'
$db{key} = "value" # writes to disk
p $db{key} # reads from disk
untie %db
</code></pre>
</article>
<article class="doc-entry" id="doc-prototype">
<h3><a class="doc-anchor" href="#doc-prototype">#</a> <code>prototype</code></h3>
<p>Return the prototype string of a named function, or <code>undef</code> 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>
<pre><code class="lang-perl">p prototype("CORE::push") # \@@
p prototype("CORE::map") # &@
fn greet($name) { p "hi $name" }
p prototype(\&greet) # undef (signatures, no proto)
</code></pre>
</article>
<article class="doc-entry" id="doc-wantarray">
<h3><a class="doc-anchor" href="#doc-wantarray">#</a> <code>wantarray</code></h3>
<p><code>wantarray()</code> — returns true if the current subroutine was called in list context, false in scalar context, and <code>undef</code> 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 <code>fn</code> to define subroutines and <code>wantarray()</code> inside them just like in Perl. Note that <code>wantarray</code> only reflects the immediate call site, not nested contexts.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-caller">
<h3><a class="doc-anchor" href="#doc-caller">#</a> <code>caller</code></h3>
<p><code>caller [LEVEL]</code> — returns information about the calling subroutine's context. In list context it returns <code>(package, filename, line)</code> 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, <code>caller</code> returns just the package name. In stryke, <code>caller</code> works with <code>fn</code>-defined subroutines and integrates with the runtime's frame tracking. This is invaluable for building custom error reporters or trace utilities.</p>
<pre><code class="lang-perl">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"
}
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-control-flow">
<h2>Control Flow</h2>
<p class="chapter-meta">17 topics</p>
<article class="doc-entry" id="doc-if">
<h3><a class="doc-anchor" href="#doc-if">#</a> <code>if</code></h3>
<p>The fundamental conditional construct. Evaluates its condition in boolean context and executes the block if true. stryke supports both the block form <code>if (COND) { BODY }</code> and the postfix form <code>EXPR if COND</code>, which is idiomatic for single-statement guards. The condition can be any expression — numbers (0 is false), strings (empty and <code>"0"</code> are false), undef (false), and references (always true). Postfix <code>if</code> cannot have <code>elsif</code>/<code>else</code> — use the block form for multi-branch logic.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-elsif">
<h3><a class="doc-anchor" href="#doc-elsif">#</a> <code>elsif</code></h3>
<p>Chain additional conditions after an <code>if</code> block without nesting. Each <code>elsif</code> 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 <code>elsif</code> branches. In stryke, prefer <code>match</code> for complex multi-branch dispatch since it supports pattern matching, destructuring, and guards — but <code>elsif</code> remains the right tool for simple linear condition chains. Note: it is <code>elsif</code>, not <code>elseif</code> or <code>else if</code> — the latter is a syntax error.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-else">
<h3><a class="doc-anchor" href="#doc-else">#</a> <code>else</code></h3>
<p>The final fallback branch of an <code>if</code>/<code>elsif</code> chain, executed when no preceding condition was true. Every <code>if</code> can have at most one <code>else</code>, and it must come last. For ternary-style expressions, use <code>COND ? A : B</code> instead of an <code>if</code>/<code>else</code> block — it composes better in <code>|></code> pipes and assignments.</p>
<pre><code class="lang-perl">if ($n % 2 == 0) { p "even" }
else { p "odd" }
# Ternary is often cleaner in pipes:
1..10 |> map { $_ % 2 == 0 ? "even" : "odd" } |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-unless">
<h3><a class="doc-anchor" href="#doc-unless">#</a> <code>unless</code></h3>
<p>A negated conditional — executes the block when the condition is *false*. This reads more naturally than <code>if (!COND)</code> for guard clauses and early returns. stryke supports both block and postfix forms. Convention: use <code>unless</code> for simple negative guards; avoid <code>unless</code> with complex compound conditions, as double-negatives hurt readability. There is no <code>unlessif</code> — use <code>if</code>/<code>elsif</code> chains for multi-branch logic.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-for">
<h3><a class="doc-anchor" href="#doc-for">#</a> <code>for</code></h3>
<p>Iterate over a list, binding each element to a loop variable (or <code>$_</code> by default). <code>for</code> and <code>foreach</code> are interchangeable keywords. The loop variable is automatically localized and aliases the original element — modifications to <code>$_</code> inside the loop mutate the list in-place. In stryke, <code>for</code> loops work with ranges, arrays, hash slices, and iterator results. For parallel iteration, see <code>pfor</code>; for pipeline-style processing, prefer <code>|> e</code> or <code>|> map</code>. C-style <code>for (INIT; COND; STEP)</code> is also supported.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-while">
<h3><a class="doc-anchor" href="#doc-while">#</a> <code>while</code></h3>
<p>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. <code>while</code> integrates naturally with the diamond operator <code><></code> for reading filehandles. The loop variable can be declared in the condition with <code>my</code>, scoping it to the loop body. Postfix form is also supported: <code>EXPR while COND;</code>.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-until">
<h3><a class="doc-anchor" href="#doc-until">#</a> <code>until</code></h3>
<p>Loop that continues as long as its condition is *false* — the logical inverse of <code>while</code>. 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 <code>while</code> with a negated condition if <code>until</code> makes the logic harder to read.</p>
<pre><code class="lang-perl">my $n = 1
until ($n > 1000) { $n *= 2 }
p $n # 1024
my $tries = 0
until (connected()) {
$tries++
sleep 1
}
p "connected after $tries tries"
</code></pre>
</article>
<article class="doc-entry" id="doc-do">
<h3><a class="doc-anchor" href="#doc-do">#</a> <code>do</code></h3>
<p>Execute a block and return its value, or execute a file. As a block, <code>do { ... }</code> creates an expression scope — the last expression in the block is the return value, making it useful for complex initializations. As a file operation, <code>do "file.pl"</code> executes the file in the current scope and returns its last expression. Unlike <code>require</code>, <code>do</code> does not cache and re-executes on each call. <code>do { ... } while (COND)</code> creates a loop that always runs at least once.</p>
<pre><code class="lang-perl">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 "")
</code></pre>
</article>
<article class="doc-entry" id="doc-last">
<h3><a class="doc-anchor" href="#doc-last">#</a> <code>last</code></h3>
<p>Immediately exit the innermost enclosing loop (equivalent to <code>break</code> in C/Rust). Execution continues after the loop. <code>last LABEL</code> can target a labeled outer loop to break out of nested loops. Works in <code>for</code>, <code>foreach</code>, <code>while</code>, <code>until</code>, and <code>do-while</code>. Does *not* work inside <code>map</code>, <code>grep</code>, or <code>|></code> pipeline stages — use <code>take</code>, <code>first</code>, or <code>take_while</code> for early termination in functional contexts.</p>
<pre><code class="lang-perl">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
}
}
</code></pre>
<p>For pipeline early-exit: <code>1..1000 |> take_while { $_ < 50 } |> e p</code>.</p>
</article>
<article class="doc-entry" id="doc-next">
<h3><a class="doc-anchor" href="#doc-next">#</a> <code>next</code></h3>
<p>Skip the rest of the current loop iteration and jump to the next one. The loop condition (for <code>while</code>/<code>until</code>) or the next element (for <code>for</code>/<code>foreach</code>) is evaluated immediately. Like <code>last</code>, <code>next</code> supports labeled loops with <code>next LABEL</code> for skipping in nested loops. This is the primary tool for filtering within imperative loops. In stryke, consider <code>grep</code>/<code>filter</code> or <code>|> reject</code> for functional-style filtering instead.</p>
<pre><code class="lang-perl">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
}
</code></pre>
</article>
<article class="doc-entry" id="doc-redo">
<h3><a class="doc-anchor" href="#doc-redo">#</a> <code>redo</code></h3>
<p>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, <code>redo</code> 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 <code>retry { ... } times => N, backoff => 'exponential'</code>.</p>
<pre><code class="lang-perl">for my $url (@urls) {
my $body = eval { fetch($url) }
if ($@) {
warn "retry $url: $@"
sleep 1
redo # try same URL again
}
p length($body)
}
</code></pre>
</article>
<article class="doc-entry" id="doc-continue">
<h3><a class="doc-anchor" href="#doc-continue">#</a> <code>continue</code></h3>
<p>A block attached to a <code>for</code>/<code>foreach</code>/<code>while</code> loop that executes after each iteration, even when <code>next</code> is called. Analogous to the increment expression in a C-style <code>for</code> loop. The <code>continue</code> block does *not* run when <code>last</code> or <code>redo</code> is used. Useful for unconditional per-iteration bookkeeping like incrementing counters, logging progress, or flushing buffers. Rarely used but fully supported in stryke.</p>
<pre><code class="lang-perl">my $count = 0
for my $item (@work) {
next if $item->{skip}
process($item)
} continue {
$count++
p "processed $count so far" if $count % 100 == 0
}
</code></pre>
</article>
<article class="doc-entry" id="doc-given">
<h3><a class="doc-anchor" href="#doc-given">#</a> <code>given</code></h3>
<p>A switch-like construct that evaluates an expression and dispatches to <code>when</code> blocks via smartmatch semantics. The topic variable <code>$_</code> is set to the <code>given</code> expression for the duration of the block. Each <code>when</code> clause is tested in order; the first match executes its block and control passes out of the <code>given</code> (implicit break). A <code>default</code> block handles the no-match case. In stryke, prefer the <code>match</code> keyword for new code — it offers pattern destructuring, typed patterns, array/hash shape matching, and <code>if</code> guards that <code>given</code>/<code>when</code> cannot express.</p>
<pre><code class="lang-perl">given ($cmd) {
when ("start") { p "starting up" }
when ("stop") { p "shutting down" }
when (/^re/) { p "restarting" }
default { p "unknown: $cmd" }
}
</code></pre>
<p>See <code>match</code> for stryke-native pattern matching with destructuring.</p>
</article>
<article class="doc-entry" id="doc-when">
<h3><a class="doc-anchor" href="#doc-when">#</a> <code>when</code></h3>
<p>A case clause inside a <code>given</code> block. The expression is matched against the topic <code>$_</code> using smartmatch semantics: strings match exactly, regexes match against <code>$_</code>, arrayrefs check membership, coderefs are called with <code>$_</code> as argument, and numbers compare numerically. When a <code>when</code> clause matches, its block executes and control exits the enclosing <code>given</code> (implicit break). Multiple <code>when</code> clauses are tried in order until one matches.</p>
<pre><code class="lang-perl">given ($val) {
when (/^\d+$/) { p "number" }
when (["a","b","c"]) { p "early letter" }
when (42) { p "the answer" }
default { p "something else" }
}
</code></pre>
<p>In stryke, the <code>match</code> keyword provides more powerful pattern matching.</p>
</article>
<article class="doc-entry" id="doc-default">
<h3><a class="doc-anchor" href="#doc-default">#</a> <code>default</code></h3>
<p>The fallback clause in a <code>given</code> block, executed when no <code>when</code> clause matched. Every <code>given</code> should have a <code>default</code> to handle unexpected values, similar to <code>else</code> in an <code>if</code> chain or the wildcard <code>_</code> arm in stryke <code>match</code>. If no <code>default</code> is present and nothing matches, execution simply continues after the <code>given</code> block. In stryke <code>match</code>, use <code>_ => ...</code> for the default arm instead.</p>
<pre><code class="lang-perl">given ($exit_code) {
when (0) { p "success" }
when (1) { p "general error" }
when (2) { p "misuse" }
default { p "unknown exit code: $exit_code" }
}
</code></pre>
</article>
<article class="doc-entry" id="doc-return">
<h3><a class="doc-anchor" href="#doc-return">#</a> <code>return</code></h3>
<p>Return a value from a subroutine.</p>
<pre><code class="lang-perl">fn clamp($v, $lo, $hi) {
return $lo if $v < $lo
return $hi if $v > $hi
$v
}
</code></pre>
</article>
<article class="doc-entry" id="doc-not">
<h3><a class="doc-anchor" href="#doc-not">#</a> <code>not</code></h3>
<p>Low-precedence logical negation — returns true if the expression is false, and false if it is true. Functionally identical to <code>!</code> but binds looser than almost everything, so <code>not $a == $b</code> is <code>not($a == $b)</code> rather than <code>(!$a) == $b</code>. Useful for readable boolean conditions.</p>
<pre><code class="lang-perl">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)
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-error-handling">
<h2>Error Handling</h2>
<p class="chapter-meta">8 topics</p>
<article class="doc-entry" id="doc-try">
<h3><a class="doc-anchor" href="#doc-try">#</a> <code>try</code></h3>
<p>Structured exception handling that cleanly separates the happy path from error recovery. The <code>try</code> block runs the code; if it throws (via <code>die</code>), execution jumps to the <code>catch</code> block with the exception bound to the declared variable. An optional <code>finally</code> block runs unconditionally afterward — ideal for cleanup like closing filehandles or releasing locks. Unlike <code>eval</code>, <code>try</code>/<code>catch</code> is a first-class statement with proper scoping and no <code>$@</code> pollution. In stryke, <code>try</code> integrates with all exception types including string messages, hashrefs, and objects.</p>
<pre><code class="lang-perl">try {
my $data = fetch_json($url)
p $data->{name}
} catch ($e) {
warn "request failed: $e"
return fallback()
} finally {
log_info("fetch attempt complete")
}
</code></pre>
<p>Prefer <code>try</code>/<code>catch</code> over <code>eval { }</code> for new code — it reads better and avoids <code>$@</code> clobbering races.</p>
</article>
<article class="doc-entry" id="doc-catch">
<h3><a class="doc-anchor" href="#doc-catch">#</a> <code>catch</code></h3>
<p>The error-handling clause that follows a <code>try</code> block. When the <code>try</code> block throws an exception, execution transfers to <code>catch</code> with the exception value bound to the declared variable (e.g. <code>$e</code>). 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 <code>ref</code> or <code>match</code> inside the catch body. If the catch block itself throws, the exception propagates upward (the <code>finally</code> block still runs first, if present).</p>
<pre><code class="lang-perl">try { die { code => 404, msg => "not found" } }
catch ($e) {
if (ref $e eq 'HASH') {
p "error $e->{code}: $e->{msg}"
} else {
p "caught: $e"
}
}
</code></pre>
</article>
<article class="doc-entry" id="doc-finally">
<h3><a class="doc-anchor" href="#doc-finally">#</a> <code>finally</code></h3>
<p>A cleanup block that runs after <code>try</code>/<code>catch</code> regardless of whether an exception was thrown or not. This guarantees resource cleanup even if the <code>try</code> block throws or the <code>catch</code> block re-throws. The <code>finally</code> block cannot change the exception or the return value — it is strictly for side effects like closing filehandles, releasing locks, or logging. If <code>finally</code> itself throws, that exception replaces the original one (avoid throwing in finally). <code>finally</code> is optional — you can use <code>try</code>/<code>catch</code> without it.</p>
<pre><code class="lang-perl">my $fh
try {
open $fh, '<', $path or die $!
process(<$fh>)
} catch ($e) {
log_error("failed: $e")
} finally {
close $fh if $fh # always cleanup
}
</code></pre>
</article>
<article class="doc-entry" id="doc-eval">
<h3><a class="doc-anchor" href="#doc-eval">#</a> <code>eval</code></h3>
<p>The classic Perl exception-catching mechanism. <code>eval { BLOCK }</code> executes the block in an exception-trapping context: if the block throws (via <code>die</code>), execution continues after the <code>eval</code> with the error stored in <code>$@</code>. <code>eval "STRING"</code> compiles and executes Perl code at runtime — powerful but dangerous (code injection risk). In stryke, prefer <code>try</code>/<code>catch</code> for exception handling as it avoids the <code>$@</code> clobbering pitfalls and reads more clearly. <code>eval</code> remains useful for dynamic code evaluation and backward compatibility with Perl 5 idioms.</p>
<pre><code class="lang-perl">eval { die "oops" }
if ($@) { p "caught: $@" }
# Eval string — dynamic code execution
my $expr = "2 + 2"
my $result = eval $expr
p $result # 4
</code></pre>
<p>Caveat: <code>$@</code> can be clobbered by intervening <code>eval</code>s or destructors — <code>try</code>/<code>catch</code> avoids this.</p>
</article>
<article class="doc-entry" id="doc-die">
<h3><a class="doc-anchor" href="#doc-die">#</a> <code>die</code></h3>
<p>Raise an exception, immediately unwinding the call stack until caught by <code>try</code>/<code>catch</code> or <code>eval</code>. 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, <code>die</code> works identically to Perl 5 and integrates with <code>try</code>/<code>catch</code>, <code>eval</code>, and the <code>$@</code> mechanism. Convention: end die messages with <code>\n</code> to suppress the automatic "at FILE line LINE" suffix, or omit it to get location info for debugging.</p>
<pre><code class="lang-perl">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.
</code></pre>
</article>
<article class="doc-entry" id="doc-warn">
<h3><a class="doc-anchor" href="#doc-warn">#</a> <code>warn</code></h3>
<p>Print a warning message to STDERR without terminating the program. Behaves like <code>die</code> but only emits the message instead of throwing an exception. If the message does not end with <code>\n</code>, Perl appends the current file and line number. Warnings can be intercepted with <code>$SIG{__WARN__}</code> or suppressed with <code>no warnings</code>. In stryke, <code>warn</code> is useful for non-fatal diagnostics; for structured logging, use <code>log_warn</code> instead.</p>
<pre><code class="lang-perl">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"
</code></pre>
</article>
<article class="doc-entry" id="doc-croak">
<h3><a class="doc-anchor" href="#doc-croak">#</a> <code>croak</code></h3>
<p>Die from the caller's perspective — the error message reports the file and line of the *caller*, not the function that called <code>croak</code>. This is the right choice for library/module functions where the error is the caller's fault (bad arguments, misuse). Without <code>croak</code>, the user sees an error pointing at library internals, which is unhelpful. In stryke, <code>croak</code> is available as a builtin without <code>use Carp</code>. For debugging deep call chains, use <code>confess</code> instead to get a full stack trace.</p>
<pre><code class="lang-perl">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"
</code></pre>
</article>
<article class="doc-entry" id="doc-confess">
<h3><a class="doc-anchor" href="#doc-confess">#</a> <code>confess</code></h3>
<p>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 <code>die</code> or <code>croak</code> only show one frame. Each frame includes the package, file, and line number. In stryke, <code>confess</code> is available as a builtin without <code>use Carp</code>. Use <code>confess</code> during development for maximum diagnostic info; switch to <code>croak</code> in production-facing libraries where the trace would confuse end users.</p>
<pre><code class="lang-perl">fn validate($data) {
confess "missing required field 'name'" unless $data->{name}
}
fn process($input) { validate($input) }
fn main { process({}) } # full trace: main -> process -> validate
</code></pre>
<p>The trace output shows: <code>missing required field 'name' at script.pl line 2.\n\tmain::validate called at line 4\n\t...</code>.</p>
</article>
</section>
<section class="tutorial-section" id="ch-declarations">
<h2>Declarations</h2>
<p class="chapter-meta">11 topics</p>
<article class="doc-entry" id="doc-my">
<h3><a class="doc-anchor" href="#doc-my">#</a> <code>my</code></h3>
<p>Declare a lexically scoped variable visible only within the enclosing block or file. <code>my</code> is the workhorse of Perl variable declarations — use it for scalars (<code>$</code>), arrays (<code>@</code>), and hashes (<code>%</code>). Variables declared with <code>my</code> are invisible outside their scope, which prevents accidental cross-scope mutation. In stryke, <code>my</code> variables participate in pipe chains and can be destructured in list context. Uninitialized <code>my</code> variables default to <code>undef</code>.</p>
<pre><code class="lang-perl">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).
</code></pre>
</article>
<article class="doc-entry" id="doc-our">
<h3><a class="doc-anchor" href="#doc-our">#</a> <code>our</code></h3>
<p>Declare a package-global variable that is accessible as a lexical alias in the current scope. Unlike <code>my</code>, <code>our</code> variables are visible across the entire package and can be accessed from other packages via their fully qualified name (e.g. <code>$Counter::total</code>). This is useful for package-level configuration, shared counters, or variables that need to survive across file boundaries. In stryke, <code>our</code> variables are not mutex-protected — use <code>mysync</code> instead for parallel-safe globals.</p>
<pre><code class="lang-perl">package Counter
our $total = 0
fn bump { $total++ }
package main
Counter::bump() for 1..5
p $Counter::total # 5
</code></pre>
<p>Prefer <code>my</code> for local state; reach for <code>our</code> only when other packages need access.</p>
</article>
<article class="doc-entry" id="doc-local">
<h3><a class="doc-anchor" href="#doc-local">#</a> <code>local</code></h3>
<p>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 <code>$/</code>, <code>$\</code>, <code>$,</code>) without permanently altering global state. Unlike <code>my</code> which creates a new variable, <code>local</code> saves and restores an existing global. In stryke, <code>local</code> works with all special variables and respects the same restoration semantics during exception unwinding.</p>
<pre><code class="lang-perl">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
</code></pre>
<p>Common patterns: <code>local $/ = undef</code> (slurp), <code>local $, = ","</code> (join print args), <code>local %ENV</code> (temporary env).</p>
</article>
<article class="doc-entry" id="doc-state">
<h3><a class="doc-anchor" href="#doc-state">#</a> <code>state</code></h3>
<p>Declare a persistent lexical variable that retains its value across calls to the enclosing subroutine. Unlike <code>my</code>, which reinitializes on each call, <code>state</code> 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, <code>state</code> variables are per-thread when used inside <code>~> { }</code> or <code>fan</code> blocks; they are not shared across workers.</p>
<pre><code class="lang-perl">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)
}
</code></pre>
<p>Requires <code>use feature 'state'</code> in standard Perl, but is always available in stryke.</p>
</article>
<article class="doc-entry" id="doc-sub">
<h3><a class="doc-anchor" href="#doc-sub">#</a> <code>sub</code></h3>
<p>Define a named or anonymous subroutine. In stryke, the preferred shorthand is <code>fn</code>, which behaves identically but is shorter and supports optional typed parameters. Named subs are installed into the current package; anonymous subs (closures) capture their enclosing lexical scope. Subroutines 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 <code>return</code> is used.</p>
<pre><code class="lang-perl">fn greet($who) { p "hello $who" }
my $sq = fn ($x) { $x ** 2 }
1..5 |> map $sq->($_) |> e p
fn apply($f, @args) { $f->(@args) }
apply($sq, 7) |> p # 49
</code></pre>
<p>Use <code>fn</code> for new stryke code; <code>sub</code> is fully supported for Perl compatibility.</p>
</article>
<article class="doc-entry" id="doc-package">
<h3><a class="doc-anchor" href="#doc-package">#</a> <code>package</code></h3>
<p>Set the current package namespace for all subsequent declarations. Package names are conventionally <code>CamelCase</code> with <code>::</code> separators (e.g. <code>Math::Utils</code>). All unqualified sub and <code>our</code> 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 <code>struct</code> or <code>bless</code> for OOP). Switching packages mid-file is allowed but discouraged; prefer one package per file.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-use">
<h3><a class="doc-anchor" href="#doc-use">#</a> <code>use</code></h3>
<p>Load and import a module at compile time: <code>use Module qw(func);</code>.</p>
<pre><code class="lang-perl">use List::Util qw(sum max)
my @vals = 1..10
p sum(@vals) # 55
p max(@vals) # 10
</code></pre>
</article>
<article class="doc-entry" id="doc-no">
<h3><a class="doc-anchor" href="#doc-no">#</a> <code>no</code></h3>
<p>Unimport a module or pragma: <code>no strict 'refs';</code>.</p>
<pre><code class="lang-perl">no warnings 'experimental'
given ($x) { when (1) { p "one" } }
</code></pre>
</article>
<article class="doc-entry" id="doc-require">
<h3><a class="doc-anchor" href="#doc-require">#</a> <code>require</code></h3>
<p>Load a module at runtime: <code>require Module;</code>.</p>
<pre><code class="lang-perl">require JSON
my $data = JSON::decode_json($text)
p $data->{name}
</code></pre>
</article>
<article class="doc-entry" id="doc-begin">
<h3><a class="doc-anchor" href="#doc-begin">#</a> <code>BEGIN</code></h3>
<p><code>BEGIN { }</code> — runs at compile time, before the rest of the program.</p>
<pre><code class="lang-perl">BEGIN { p "compiling..." }
p "running"
# output: compiling... then running
</code></pre>
</article>
<article class="doc-entry" id="doc-end">
<h3><a class="doc-anchor" href="#doc-end">#</a> <code>END</code></h3>
<p><code>END { }</code> — runs after the program finishes (or on exit).</p>
<pre><code class="lang-perl">END { p "cleanup done" }
p "main work"
# output: main work then cleanup done
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-cluster-distributed">
<h2>Cluster / Distributed</h2>
<p class="chapter-meta">4 topics</p>
<article class="doc-entry" id="doc-cluster">
<h3><a class="doc-anchor" href="#doc-cluster">#</a> <code>cluster</code></h3>
<p><code>cluster(["host1:N", "host2:M", ...])</code> — build an SSH-backed worker pool for distributing stryke workloads across multiple machines.</p>
<p>Each entry in the list is a hostname (or <code>user@host</code>) 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 <code>stryke --remote-worker</code> processes, and manages a work-stealing scheduler across the entire cluster. The cluster object is then passed to distributed primitives like <code>pmap_on</code> and <code>pflat_map_on</code>. Workers must have <code>stryke</code> installed and accessible on <code>$PATH</code>. If a host becomes unreachable mid-computation, its in-flight tasks are automatically re-queued to surviving hosts.</p>
<pre><code class="lang-perl">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"])
</code></pre>
</article>
<article class="doc-entry" id="doc-pmap-on">
<h3><a class="doc-anchor" href="#doc-pmap-on">#</a> <code>pmap_on</code></h3>
<p><code>pmap_on $cluster, { BLOCK } @list</code> — distributed parallel map that fans work across a <code>cluster</code> of remote machines.</p>
<p>Elements from <code>@list</code> are serialized, shipped to remote <code>stryke --remote-worker</code> 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 <code>pmap</code>: 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.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-pflat-map-on">
<h3><a class="doc-anchor" href="#doc-pflat-map-on">#</a> <code>pflat_map_on</code></h3>
<p>Distributed parallel flat-map over <code>cluster</code>.</p>
</article>
<article class="doc-entry" id="doc-ssh">
<h3><a class="doc-anchor" href="#doc-ssh">#</a> <code>ssh</code></h3>
<p><code>ssh($host, $command)</code> — execute a shell command on a remote host via SSH and return its stdout as a string.</p>
<p>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 <code>cluster</code> + <code>pmap_on</code> which manages connection pooling and parallelism automatically. <code>ssh</code> is best for one-off administrative commands, health checks, or bootstrapping a remote environment before building a cluster.</p>
<pre><code class="lang-perl">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")
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-datetime">
<h2>Datetime</h2>
<p class="chapter-meta">15 topics</p>
<article class="doc-entry" id="doc-datetime-utc">
<h3><a class="doc-anchor" href="#doc-datetime-utc">#</a> <code>datetime_utc</code></h3>
<p>Return the current UTC date and time as an ISO 8601 string (e.g. <code>2026-04-15T12:30:00Z</code>). This is the simplest way to get a portable, unambiguous timestamp for logging, file naming, or serialization. The returned string always ends with <code>Z</code> indicating UTC, so there is no timezone ambiguity.</p>
<pre><code class="lang-perl">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)
</code></pre>
</article>
<article class="doc-entry" id="doc-datetime-from-epoch">
<h3><a class="doc-anchor" href="#doc-datetime-from-epoch">#</a> <code>datetime_from_epoch</code></h3>
<p>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 <code>time()</code>, file modification times, or external APIs and need a human-readable representation. Fractional seconds are truncated.</p>
<pre><code class="lang-perl">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 }
</code></pre>
</article>
<article class="doc-entry" id="doc-datetime-strftime">
<h3><a class="doc-anchor" href="#doc-datetime-strftime">#</a> <code>datetime_strftime</code></h3>
<p>Format an epoch timestamp using a <code>strftime</code>-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: <code>%Y</code> (4-digit year), <code>%m</code> (month), <code>%d</code> (day), <code>%H</code> (hour), <code>%M</code> (minute), <code>%S</code> (second), <code>%A</code> (weekday name), and more.</p>
<pre><code class="lang-perl">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)
</code></pre>
</article>
<article class="doc-entry" id="doc-datetime-now-tz">
<h3><a class="doc-anchor" href="#doc-datetime-now-tz">#</a> <code>datetime_now_tz</code></h3>
<p>Return the current date and time in a specified IANA timezone as a formatted string. Pass a timezone name like <code>America/New_York</code>, <code>Europe/London</code>, or <code>Asia/Tokyo</code>. This avoids manual UTC-offset arithmetic and handles daylight saving transitions correctly. Dies if the timezone name is not recognized.</p>
<pre><code class="lang-perl">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 }
</code></pre>
</article>
<article class="doc-entry" id="doc-datetime-format-tz">
<h3><a class="doc-anchor" href="#doc-datetime-format-tz">#</a> <code>datetime_format_tz</code></h3>
<p>Format an epoch timestamp in a specific IANA timezone, combining the capabilities of <code>datetime_strftime</code> and <code>datetime_now_tz</code>. This lets you render a historical or future timestamp as it would appear on the wall clock in any timezone. Handles DST transitions automatically.</p>
<pre><code class="lang-perl">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")
</code></pre>
</article>
<article class="doc-entry" id="doc-datetime-parse-local">
<h3><a class="doc-anchor" href="#doc-datetime-parse-local">#</a> <code>datetime_parse_local</code></h3>
<p>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 <code>2026-04-15 14:30:00</code> or <code>2026-04-15T14:30:00</code>. Dies if the string cannot be parsed. This is the inverse of formatting with <code>localtime</code>.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-datetime-parse-rfc3339">
<h3><a class="doc-anchor" href="#doc-datetime-parse-rfc3339">#</a> <code>datetime_parse_rfc3339</code></h3>
<p>Parse an RFC 3339 / ISO 8601 datetime string (with timezone offset or <code>Z</code> suffix) into a Unix epoch timestamp. This is the standard format used by JSON APIs, RSS feeds, and git timestamps. Accepts strings like <code>2026-04-15T14:30:00Z</code> or <code>2026-04-15T14:30:00+05:30</code>. Dies on malformed input.</p>
<pre><code class="lang-perl">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"
</code></pre>
</article>
<article class="doc-entry" id="doc-datetime-add-seconds">
<h3><a class="doc-anchor" href="#doc-datetime-add-seconds">#</a> <code>datetime_add_seconds</code></h3>
<p>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.</p>
<pre><code class="lang-perl">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"
</code></pre>
</article>
<article class="doc-entry" id="doc-elapsed">
<h3><a class="doc-anchor" href="#doc-elapsed">#</a> <code>elapsed</code></h3>
<p>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 <code>el</code> 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.</p>
<pre><code class="lang-perl">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") }
</code></pre>
</article>
<article class="doc-entry" id="doc-time">
<h3><a class="doc-anchor" href="#doc-time">#</a> <code>time</code></h3>
<p>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 <code>elapsed</code>/<code>el</code> instead since <code>time</code> can jump if the system clock is adjusted.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-times">
<h3><a class="doc-anchor" href="#doc-times">#</a> <code>times</code></h3>
<p>Return the accumulated CPU times for the process as a four-element list: <code>($user, $system, $child_user, $child_system)</code>. 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.</p>
<pre><code class="lang-perl">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"
</code></pre>
</article>
<article class="doc-entry" id="doc-localtime">
<h3><a class="doc-anchor" href="#doc-localtime">#</a> <code>localtime</code></h3>
<p>Convert a Unix epoch timestamp to a nine-element list of broken-down local time components: <code>($sec, $min, $hour, $mday, $mon, $year, $wday, $yday, $isdst)</code>. Follows the Perl convention where <code>$mon</code> is 0-based (January=0) and <code>$year</code> is years since 1900. When called without arguments, uses the current time. Use <code>gmtime</code> for the UTC equivalent.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-gmtime">
<h3><a class="doc-anchor" href="#doc-gmtime">#</a> <code>gmtime</code></h3>
<p>Convert a Unix epoch timestamp to a nine-element list of broken-down UTC time components, identical in structure to <code>localtime</code> but always in the UTC timezone. The fields are <code>($sec, $min, $hour, $mday, $mon, $year, $wday, $yday, $isdst)</code> where <code>$isdst</code> is always 0. When called without arguments, uses the current time.</p>
<pre><code class="lang-perl">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]"
</code></pre>
</article>
<article class="doc-entry" id="doc-sleep">
<h3><a class="doc-anchor" href="#doc-sleep">#</a> <code>sleep</code></h3>
<p>Pause execution for the specified number of seconds. Accepts both integer and fractional values for sub-second sleeps (e.g. <code>sleep 0.1</code> 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>
<pre><code class="lang-perl">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) }
</code></pre>
</article>
<article class="doc-entry" id="doc-alarm">
<h3><a class="doc-anchor" href="#doc-alarm">#</a> <code>alarm</code></h3>
<p>Schedule a <code>SIGALRM</code> signal to be delivered to the process after the specified number of seconds. Calling <code>alarm(0)</code> 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 <code>eval</code> and <code>$SIG{ALRM}</code> to implement timeouts around potentially hanging operations.</p>
<pre><code class="lang-perl">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")
}
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-math">
<h2>Math</h2>
<p class="chapter-meta">13 topics</p>
<article class="doc-entry" id="doc-abs">
<h3><a class="doc-anchor" href="#doc-abs">#</a> <code>abs</code></h3>
<p>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>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-int">
<h3><a class="doc-anchor" href="#doc-int">#</a> <code>int</code></h3>
<p>Truncate a floating-point number toward zero, discarding the fractional part. This is not rounding — <code>int(1.9)</code> is <code>1</code> and <code>int(-1.9)</code> is <code>-1</code>. Use <code>sprintf("%.0f", $n)</code> or <code>POSIX::round</code> for proper rounding. Commonly paired with <code>rand</code> to generate random integers.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-sqrt">
<h3><a class="doc-anchor" href="#doc-sqrt">#</a> <code>sqrt</code></h3>
<p>Return the square root of a non-negative number. Dies if the argument is negative — use <code>abs</code> first or check the sign. For the inverse operation, use <code>squared</code>/<code>sq</code> or the <code>**</code> operator.</p>
<pre><code class="lang-perl">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", $_) }
</code></pre>
</article>
<article class="doc-entry" id="doc-squared">
<h3><a class="doc-anchor" href="#doc-squared">#</a> <code>squared</code></h3>
<p>Return the square of a number (<code>N * N</code>). This is a stryke convenience function — clearer than writing <code>$n ** 2</code> or <code>$n * $n</code> in pipelines. The aliases <code>sq</code> and <code>square</code> are interchangeable.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-cubed">
<h3><a class="doc-anchor" href="#doc-cubed">#</a> <code>cubed</code></h3>
<p>Return the cube of a number (<code>N * N * N</code>). This is a stryke convenience function for the common <code>$n ** 3</code> operation, useful in math-heavy pipelines. The aliases <code>cb</code> and <code>cube</code> are interchangeable.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-expt">
<h3><a class="doc-anchor" href="#doc-expt">#</a> <code>expt</code></h3>
<p>Raise a base to an arbitrary exponent and return the result. This is the function form of the <code>**</code> operator. Accepts integer and floating-point exponents, including negative values for reciprocals and fractional values for roots.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-exp">
<h3><a class="doc-anchor" href="#doc-exp">#</a> <code>exp</code></h3>
<p>Return Euler's number *e* raised to the given power. <code>exp(0)</code> is <code>1</code>, <code>exp(1)</code> is approximately <code>2.71828</code>. This is the inverse of <code>log</code>. Useful for exponential growth/decay calculations, probability distributions, and converting between logarithmic and linear scales.</p>
<pre><code class="lang-perl">p exp(1) # 2.71828182845905
p exp(0) # 1
my $growth = $initial * exp($rate * $time)
1..5 |> map exp |> e { p sprintf("%.4f", $_) }
</code></pre>
</article>
<article class="doc-entry" id="doc-log">
<h3><a class="doc-anchor" href="#doc-log">#</a> <code>log</code></h3>
<p>Return the natural (base-*e*) logarithm of a positive number. Dies if the argument is zero or negative. For base-10 logarithms, divide by <code>log(10)</code>. For base-2, divide by <code>log(2)</code>. This is the inverse of <code>exp</code>.</p>
<pre><code class="lang-perl">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", $_) }
</code></pre>
</article>
<article class="doc-entry" id="doc-sin">
<h3><a class="doc-anchor" href="#doc-sin">#</a> <code>sin</code></h3>
<p>Return the sine of an angle given in radians. The result ranges from <code>-1</code> to <code>1</code>. For degrees, convert first: <code>sin($deg * 3.14159265 / 180)</code>. Use <code>atan2</code> to go in the reverse direction.</p>
<pre><code class="lang-perl">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", $_) }
</code></pre>
</article>
<article class="doc-entry" id="doc-cos">
<h3><a class="doc-anchor" href="#doc-cos">#</a> <code>cos</code></h3>
<p>Return the cosine of an angle given in radians. The result ranges from <code>-1</code> to <code>1</code>. <code>cos(0)</code> is <code>1</code>. Like <code>sin</code>, convert degrees to radians before calling.</p>
<pre><code class="lang-perl">p cos(0) # 1
p cos(3.14159265) # -1.0
my $x = $radius * cos($theta)
my $y = $radius * sin($theta)
p "($x, $y)"
</code></pre>
</article>
<article class="doc-entry" id="doc-atan2">
<h3><a class="doc-anchor" href="#doc-atan2">#</a> <code>atan2</code></h3>
<p>Return the arctangent of <code>Y/X</code> in radians, using the signs of both arguments to determine the correct quadrant. The result ranges from <code>-pi</code> to <code>pi</code>. This is the standard way to compute angles from Cartesian coordinates and is more robust than <code>atan(Y/X)</code> because it handles <code>X=0</code> correctly.</p>
<pre><code class="lang-perl">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)
</code></pre>
</article>
<article class="doc-entry" id="doc-rand">
<h3><a class="doc-anchor" href="#doc-rand">#</a> <code>rand</code></h3>
<p>Return a pseudo-random floating-point number in the range <code>[0, N)</code>. If N is omitted it defaults to <code>1</code>. The result is never exactly equal to N. For integer results, combine with <code>int</code>. Seed the generator with <code>srand</code> for reproducible sequences.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-srand">
<h3><a class="doc-anchor" href="#doc-srand">#</a> <code>srand</code></h3>
<p>Seed the pseudo-random number generator used by <code>rand</code>. Calling <code>srand</code> 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 <code>rand</code>.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-file-system">
<h2>File System</h2>
<p class="chapter-meta">34 topics</p>
<article class="doc-entry" id="doc-basename">
<h3><a class="doc-anchor" href="#doc-basename">#</a> <code>basename</code></h3>
<p>Extract the filename component from a path, stripping all leading directory segments. The short alias <code>bn</code> 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>
<pre><code class="lang-perl">p basename("/usr/local/bin/stryke") # stryke
p bn("/tmp/data.csv", ".csv") # data
"/etc/nginx/nginx.conf" |> bn |> p # nginx.conf
</code></pre>
</article>
<article class="doc-entry" id="doc-dirname">
<h3><a class="doc-anchor" href="#doc-dirname">#</a> <code>dirname</code></h3>
<p>Return the directory portion of a path, stripping the final filename component. The short alias <code>dn</code> mirrors <code>bn</code>. 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>
<pre><code class="lang-perl">p dirname("/usr/local/bin/stryke") # /usr/local/bin
p dn("/tmp/data.csv") # /tmp
my $dir = dn($0) # directory of current script
</code></pre>
</article>
<article class="doc-entry" id="doc-fileparse">
<h3><a class="doc-anchor" href="#doc-fileparse">#</a> <code>fileparse</code></h3>
<p>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 <code>File::Basename::fileparse</code> and is the most flexible path decomposition available. When no suffix patterns are given the suffix is empty.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-realpath">
<h3><a class="doc-anchor" href="#doc-realpath">#</a> <code>realpath</code></h3>
<p>Resolve a path to its absolute canonical form by following all symbolic links and eliminating <code>.</code> and <code>..</code> segments. Unlike <code>canonpath</code>, this hits the filesystem and will die if any component does not exist. The short alias <code>rp</code> is convenient in pipelines. Use this when you need a guaranteed unique path for deduplication or comparison.</p>
<pre><code class="lang-perl">p realpath(".") # /home/user/project
p rp("../sibling") # /home/user/sibling
my $canon = rp($0) # absolute path of current script
"." |> rp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-canonpath">
<h3><a class="doc-anchor" href="#doc-canonpath">#</a> <code>canonpath</code></h3>
<p>Clean up a file path by collapsing redundant separators, resolving <code>.</code> and <code>..</code> segments, and normalizing trailing slashes — all without touching the filesystem. Unlike <code>realpath</code>, 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>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-getcwd">
<h3><a class="doc-anchor" href="#doc-getcwd">#</a> <code>getcwd</code></h3>
<p>Return the current working directory as an absolute path string. This calls the underlying OS <code>getcwd</code> function, so it always reflects the real directory even if the process changed directories via <code>chdir</code>. The alias <code>pwd</code> matches the familiar shell command. Often used to save and restore directory context around <code>chdir</code> calls.</p>
<pre><code class="lang-perl">my $orig = pwd()
chdir("/tmp")
p pwd() # /tmp
chdir($orig)
p getcwd() # back to original
</code></pre>
</article>
<article class="doc-entry" id="doc-which">
<h3><a class="doc-anchor" href="#doc-which">#</a> <code>which</code></h3>
<p>Search the <code>PATH</code> environment variable for the first executable matching the given command name and return its absolute path, or <code>undef</code> if not found. This is the programmatic equivalent of the shell <code>which</code> command. Useful for checking tool availability before calling <code>system</code> or <code>exec</code>.</p>
<pre><code class="lang-perl">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")
}
</code></pre>
</article>
<article class="doc-entry" id="doc-glob">
<h3><a class="doc-anchor" href="#doc-glob">#</a> <code>glob</code></h3>
<p>Expand a shell-style glob pattern against the filesystem and return a list of matching paths. Supports <code>*</code>, <code>?</code>, <code>[abc]</code>, <code>{a,b}</code> patterns, and <code>**</code> for recursive matching. This actually reads the filesystem, unlike <code>glob_match</code> which is a pure string test.</p>
<pre><code class="lang-perl">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")
</code></pre>
</article>
<article class="doc-entry" id="doc-glob-match">
<h3><a class="doc-anchor" href="#doc-glob-match">#</a> <code>glob_match</code></h3>
<p>Test whether a filename or path matches a shell-style glob pattern. Returns true (1) on match, false (empty string) otherwise. Supports <code>*</code>, <code>?</code>, <code>[abc]</code>, and <code>{a,b}</code> 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>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-copy">
<h3><a class="doc-anchor" href="#doc-copy">#</a> <code>copy</code></h3>
<p>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 <code>cp</code> and avoids shelling out. Metadata such as permissions is preserved where possible.</p>
<pre><code class="lang-perl">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)
</code></pre>
</article>
<article class="doc-entry" id="doc-move">
<h3><a class="doc-anchor" href="#doc-move">#</a> <code>move</code></h3>
<p>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 <code>mv</code> mirrors the shell command.</p>
<pre><code class="lang-perl">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")
</code></pre>
</article>
<article class="doc-entry" id="doc-rename">
<h3><a class="doc-anchor" href="#doc-rename">#</a> <code>rename</code></h3>
<p>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 <code>move</code>/<code>mv</code>, this does not fall back to copy-then-delete across filesystems.</p>
<pre><code class="lang-perl">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)
</code></pre>
</article>
<article class="doc-entry" id="doc-unlink">
<h3><a class="doc-anchor" href="#doc-unlink">#</a> <code>unlink</code></h3>
<p>Delete one or more files from the filesystem. Returns the number of files successfully removed. Does not remove directories — use <code>rmdir</code> for those. Dies on permission errors. Accepts a list of paths, making it convenient for batch cleanup.</p>
<pre><code class="lang-perl">unlink("temp.log")
my $n = unlink("a.tmp", "b.tmp", "c.tmp")
p "removed $n files"
my @old = glob("*.bak")
unlink(@old)
</code></pre>
</article>
<article class="doc-entry" id="doc-mkdir">
<h3><a class="doc-anchor" href="#doc-mkdir">#</a> <code>mkdir</code></h3>
<p>Create a directory at the given path. An optional second argument specifies the permission mode as an octal number (default <code>0777</code>, modified by the current <code>umask</code>). Dies if the directory cannot be created. Only creates one level — use <code>make_path</code> or shell out for recursive creation.</p>
<pre><code class="lang-perl">mkdir("output")
mkdir("/tmp/secure", 0700)
my $dir = tdr() . "/sub"
mkdir($dir)
p -d $dir # 1
</code></pre>
</article>
<article class="doc-entry" id="doc-rmdir">
<h3><a class="doc-anchor" href="#doc-rmdir">#</a> <code>rmdir</code></h3>
<p>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 <code>unlink</code> first, then call <code>rmdir</code>.</p>
<pre><code class="lang-perl">mkdir("scratch")
rmdir("scratch")
p -d "scratch" # (empty, dir is gone)
unlink("tmp/file.txt")
rmdir("tmp")
</code></pre>
</article>
<article class="doc-entry" id="doc-chmod">
<h3><a class="doc-anchor" href="#doc-chmod">#</a> <code>chmod</code></h3>
<p>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 <code>stat</code> to read the current mode before modifying.</p>
<pre><code class="lang-perl">chmod(0755, "script.pl")
chmod(0644, "config.yaml", "data.json")
my $n = chmod(0600, glob("*.key"))
p "secured $n key files"
</code></pre>
</article>
<article class="doc-entry" id="doc-chown">
<h3><a class="doc-anchor" href="#doc-chown">#</a> <code>chown</code></h3>
<p>Change the owner and group of one or more files, specified as numeric UID and GID. Pass <code>-1</code> for either to leave it unchanged. Returns the number of files successfully changed. Typically requires root privileges.</p>
<pre><code class="lang-perl">chown(1000, 1000, "app.log")
chown(-1, 100, "shared.txt") # change group only
my $uid = (getpwnam("deploy"))[2]
chown($uid, -1, "release.tar")
</code></pre>
</article>
<article class="doc-entry" id="doc-chdir">
<h3><a class="doc-anchor" href="#doc-chdir">#</a> <code>chdir</code></h3>
<p>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 <code>getcwd</code>/<code>pwd</code> to save and restore the original directory.</p>
<pre><code class="lang-perl">my $orig = pwd()
chdir("/tmp")
spurt("scratch.txt", "hello")
chdir($orig) # return to original
</code></pre>
</article>
<article class="doc-entry" id="doc-stat">
<h3><a class="doc-anchor" href="#doc-stat">#</a> <code>stat</code></h3>
<p>Return a 13-element list of file status information for a path or filehandle: <code>($dev, $ino, $mode, $nlink, $uid, $gid, $rdev, $size, $atime, $mtime, $ctime, $blksize, $blocks)</code>. This calls the POSIX <code>stat</code> system call. Use it to check file size, modification time, permissions, and other metadata without reading the file.</p>
<pre><code class="lang-perl">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)
</code></pre>
</article>
<article class="doc-entry" id="doc-link">
<h3><a class="doc-anchor" href="#doc-link">#</a> <code>link</code></h3>
<p>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.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-symlink">
<h3><a class="doc-anchor" href="#doc-symlink">#</a> <code>symlink</code></h3>
<p>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 <code>readlink</code> to inspect where a symlink points.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-readlink">
<h3><a class="doc-anchor" href="#doc-readlink">#</a> <code>readlink</code></h3>
<p>Return the target path that a symbolic link points to, without following the link further. Returns <code>undef</code> 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.</p>
<pre><code class="lang-perl">symlink("real.conf", "link.conf")
my $target = readlink("link.conf")
p $target # real.conf
if (defined readlink($path)) {
p "$path is a symlink"
}
</code></pre>
</article>
<article class="doc-entry" id="doc-utime">
<h3><a class="doc-anchor" href="#doc-utime">#</a> <code>utime</code></h3>
<p>Set the access time and modification time of one or more files. Times are specified as epoch seconds. Pass <code>undef</code> 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.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-umask">
<h3><a class="doc-anchor" href="#doc-umask">#</a> <code>umask</code></h3>
<p>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 <code>mkdir</code>, <code>open</code>, etc.</p>
<pre><code class="lang-perl">my $old = umask(0077) # restrict: owner-only
mkdir("private") # created with 0700
umask($old) # restore previous mask
p sprintf("%04o", umask()) # print current mask
</code></pre>
</article>
<article class="doc-entry" id="doc-uname">
<h3><a class="doc-anchor" href="#doc-uname">#</a> <code>uname</code></h3>
<p>Return system identification as a five-element list: <code>($sysname, $nodename, $release, $version, $machine)</code>. This calls the POSIX <code>uname</code> system call and is useful for platform-specific logic, logging system info, or generating diagnostic reports without shelling out.</p>
<pre><code class="lang-perl">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")
</code></pre>
</article>
<article class="doc-entry" id="doc-gethostname">
<h3><a class="doc-anchor" href="#doc-gethostname">#</a> <code>gethostname</code></h3>
<p>Return the hostname of the current machine as a string. This calls the POSIX <code>gethostname</code> system call. The short alias <code>hn</code> is useful in log prefixes, temp-file naming, or distributed-system identifiers where you need to tag output by machine.</p>
<pre><code class="lang-perl">p gethostname() # myhost.local
my $log_prefix = hn() . ":" . $$ # myhost.local:12345
log_info("running on " . hn())
</code></pre>
</article>
<article class="doc-entry" id="doc-opendir">
<h3><a class="doc-anchor" href="#doc-opendir">#</a> <code>opendir</code></h3>
<p>Open a directory handle for reading its entries. Returns a directory handle that can be passed to <code>readdir</code>, <code>seekdir</code>, <code>telldir</code>, <code>rewinddir</code>, and <code>closedir</code>. Dies if the directory does not exist or cannot be opened. For most use cases <code>glob</code> or <code>readdir</code> with a path is simpler.</p>
<pre><code class="lang-perl">opendir(my $dh, "/tmp") or die "cannot open: $!"
my @entries = readdir($dh)
closedir($dh)
@entries |> grep { $_ !~ /^\./ } |> e p # skip dotfiles
</code></pre>
</article>
<article class="doc-entry" id="doc-readdir">
<h3><a class="doc-anchor" href="#doc-readdir">#</a> <code>readdir</code></h3>
<p>Read entries from a directory handle opened with <code>opendir</code>. In list context, returns all remaining entries. In scalar context, returns the next single entry or <code>undef</code> when exhausted. Entries include <code>.</code> and <code>..</code> so you typically filter them out.</p>
<pre><code class="lang-perl">opendir(my $dh, ".") or die $!
while (my $entry = readdir($dh)) {
next if $entry =~ /^\./
p $entry
}
closedir($dh)
</code></pre>
</article>
<article class="doc-entry" id="doc-closedir">
<h3><a class="doc-anchor" href="#doc-closedir">#</a> <code>closedir</code></h3>
<p>Close a directory handle previously opened with <code>opendir</code>, releasing the underlying OS resource. While directory handles are closed automatically when they go out of scope, explicit <code>closedir</code> is good practice in long-running programs or loops that open many directories.</p>
<pre><code class="lang-perl">opendir(my $dh, "/var/log") or die $!
my @logs = readdir($dh)
closedir($dh)
@logs |> grep { /\.log$/ } |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-seekdir">
<h3><a class="doc-anchor" href="#doc-seekdir">#</a> <code>seekdir</code></h3>
<p>Set the current position in a directory handle to a location previously obtained from <code>telldir</code>. This allows you to revisit directory entries without closing and reopening the handle. Rarely needed in practice, but useful for multi-pass directory scanning.</p>
<pre><code class="lang-perl">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)
</code></pre>
</article>
<article class="doc-entry" id="doc-telldir">
<h3><a class="doc-anchor" href="#doc-telldir">#</a> <code>telldir</code></h3>
<p>Return the current read position within a directory handle as an opaque integer. The returned value can be passed to <code>seekdir</code> to return to that position later. This is the directory-handle equivalent of <code>tell</code> for file handles.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-rewinddir">
<h3><a class="doc-anchor" href="#doc-rewinddir">#</a> <code>rewinddir</code></h3>
<p>Reset a directory handle back to the beginning so that the next <code>readdir</code> 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.</p>
<pre><code class="lang-perl">opendir(my $dh, "src") or die $!
my $count = scalar readdir($dh)
rewinddir($dh)
my @entries = readdir($dh)
closedir($dh)
p "$count entries"
</code></pre>
</article>
<article class="doc-entry" id="doc-du">
<h3><a class="doc-anchor" href="#doc-du">#</a> <code>du</code></h3>
<p><code>du</code> (alias <code>dir_size</code>) — compute the total size of a directory tree in bytes, recursively walking all files.</p>
<pre><code class="lang-perl">my $bytes = du("/usr/local")
p "$bytes bytes"
</code></pre>
</article>
<article class="doc-entry" id="doc-du-tree">
<h3><a class="doc-anchor" href="#doc-du-tree">#</a> <code>du_tree</code></h3>
<p><code>du_tree</code> (alias <code>dir_sizes</code>) — return directory sizes as an array of hashrefs <code>{path, size}</code>, sorted descending by size. Each entry is an immediate child directory.</p>
<pre><code class="lang-perl">my @dirs = du_tree("/usr/local")
for (@dirs) { p "$_->{path}: $_->{size}" }
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-process">
<h2>Process</h2>
<p class="chapter-meta">21 topics</p>
<article class="doc-entry" id="doc-system">
<h3><a class="doc-anchor" href="#doc-system">#</a> <code>system</code></h3>
<p>Execute a command in a subshell and wait for it to complete, returning the exit status. A return value of <code>0</code> means success; non-zero indicates failure. The exit status is encoded as <code>$? >> 8</code> for the actual exit code. Use backticks or <code>capture</code> if you need the command's output.</p>
<pre><code class="lang-perl">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"
}
</code></pre>
</article>
<article class="doc-entry" id="doc-exec">
<h3><a class="doc-anchor" href="#doc-exec">#</a> <code>exec</code></h3>
<p>Replace the current process image entirely with a new command. This never returns on success — the new program takes over. If <code>exec</code> fails (command not found, permission denied) it returns false and execution continues. Use <code>system</code> instead if you want to run a command and keep the current process alive.</p>
<pre><code class="lang-perl">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")
}
</code></pre>
</article>
<article class="doc-entry" id="doc-fork">
<h3><a class="doc-anchor" href="#doc-fork">#</a> <code>fork</code></h3>
<p>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 <code>0</code> to the child, allowing each side to branch. Returns <code>undef</code> on failure. Always pair with <code>wait</code>/<code>waitpid</code> to reap the child and avoid zombies.</p>
<pre><code class="lang-perl">my $pid = fork()
if ($pid == 0) {
p "child $$"
exit(0)
}
p "parent $$, child is $pid"
waitpid($pid, 0)
</code></pre>
</article>
<article class="doc-entry" id="doc-wait">
<h3><a class="doc-anchor" href="#doc-wait">#</a> <code>wait</code></h3>
<p>Wait for any child process to terminate and return its PID. The exit status is stored in <code>$?</code>. If there are no child processes, returns <code>-1</code>. This is the simplest reaping function — use <code>waitpid</code> when you need to wait for a specific child or use non-blocking flags.</p>
<pre><code class="lang-perl">for (1..3) {
fork() or do { sleep(1)
exit(0) }
}
while ((my $pid = wait()) != -1) {
p "child $pid exited with " . ($? >> 8)
}
</code></pre>
</article>
<article class="doc-entry" id="doc-waitpid">
<h3><a class="doc-anchor" href="#doc-waitpid">#</a> <code>waitpid</code></h3>
<p>Wait for a specific child process identified by PID to change state. The flags argument controls behavior — use <code>0</code> for blocking wait, or <code>WNOHANG</code> for non-blocking (returns <code>0</code> if child is still running). Returns the PID on success, <code>-1</code> if the child does not exist. Exit status is in <code>$?</code>.</p>
<pre><code class="lang-perl">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)
}
</code></pre>
</article>
<article class="doc-entry" id="doc-kill">
<h3><a class="doc-anchor" href="#doc-kill">#</a> <code>kill</code></h3>
<p>Send a signal to one or more processes by PID. The signal can be specified as a number (<code>9</code>) or a name (<code>"TERM"</code>). Sending signal <code>0</code> tests whether the process exists without actually sending anything. Returns the number of processes successfully signaled.</p>
<pre><code class="lang-perl">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"
</code></pre>
</article>
<article class="doc-entry" id="doc-exit">
<h3><a class="doc-anchor" href="#doc-exit">#</a> <code>exit</code></h3>
<p>Terminate the program immediately with the given exit status code. An exit code of <code>0</code> conventionally means success; any non-zero value indicates an error. <code>END</code> blocks and object destructors are still run. Use <code>POSIX::_exit</code> to skip cleanup entirely.</p>
<pre><code class="lang-perl">exit(0) # success
exit(1) if $error # failure
# conditional exit in a pipeline
my $ok = system("make test")
exit($ok >> 8) if $ok
</code></pre>
</article>
<article class="doc-entry" id="doc-getlogin">
<h3><a class="doc-anchor" href="#doc-getlogin">#</a> <code>getlogin</code></h3>
<p>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 <code>undef</code> for processes without a controlling terminal (cron jobs, daemons). For a more reliable alternative, use <code>getpwuid($<)</code> which looks up the effective UID.</p>
<pre><code class="lang-perl">my $user = getlogin() // (getpwuid($<))[0]
p "running as $user"
log_info("session started by " . getlogin())
</code></pre>
</article>
<article class="doc-entry" id="doc-getpwnam">
<h3><a class="doc-anchor" href="#doc-getpwnam">#</a> <code>getpwnam</code></h3>
<p>Look up user account information by username string. Returns the same 9-element list as <code>getpwuid</code>: <code>($name, $passwd, $uid, $gid, $quota, $comment, $gcos, $dir, $shell)</code>. Returns empty list if the user does not exist. Useful for resolving a username to a UID before calling <code>chown</code>.</p>
<pre><code class="lang-perl">my @info = getpwnam("deploy")
p "uid=$info[2] home=$info[7]"
my $uid = (getpwnam("www-data"))[2]
chown($uid, -1, "public/index.html")
</code></pre>
</article>
<article class="doc-entry" id="doc-getpwuid">
<h3><a class="doc-anchor" href="#doc-getpwuid">#</a> <code>getpwuid</code></h3>
<p>Look up user account information by numeric UID. Returns <code>($name, $passwd, $uid, $gid, $quota, $comment, $gcos, $dir, $shell)</code> 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.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-getpwent">
<h3><a class="doc-anchor" href="#doc-getpwent">#</a> <code>getpwent</code></h3>
<p>Read the next entry from the system password database, iterating through all user accounts. Returns <code>($name, $passwd, $uid, $gid, $quota, $comment, $gcos, $dir, $shell)</code> for each user, or empty list when exhausted. Call <code>setpwent</code> to rewind and <code>endpwent</code> to close.</p>
<pre><code class="lang-perl">while (my @pw = getpwent()) {
p "$pw[0]: uid=$pw[2] home=$pw[7]"
}
endpwent()
</code></pre>
</article>
<article class="doc-entry" id="doc-getgrgid">
<h3><a class="doc-anchor" href="#doc-getgrgid">#</a> <code>getgrgid</code></h3>
<p>Look up group information by numeric GID. Returns <code>($name, $passwd, $gid, $members)</code> where members is a space-separated string of usernames belonging to the group. Returns empty list if the GID does not exist.</p>
<pre><code class="lang-perl">my ($name, undef, undef, $members) = getgrgid(0)
p "group $name: $members"
my $gname = (getgrgid((stat("file.txt"))[5]))[0]
p "file group: $gname"
</code></pre>
</article>
<article class="doc-entry" id="doc-getgrnam">
<h3><a class="doc-anchor" href="#doc-getgrnam">#</a> <code>getgrnam</code></h3>
<p>Look up group information by group name string. Returns <code>($name, $passwd, $gid, $members)</code>. Useful for resolving a group name to a GID before calling <code>chown</code>, or for checking group membership.</p>
<pre><code class="lang-perl">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"
}
</code></pre>
</article>
<article class="doc-entry" id="doc-getgrent">
<h3><a class="doc-anchor" href="#doc-getgrent">#</a> <code>getgrent</code></h3>
<p>Read the next entry from the system group database, iterating through all groups. Returns <code>($name, $passwd, $gid, $members)</code> for each group, or empty list when exhausted. The members field is a space-separated string of usernames. Call <code>endgrent</code> when done.</p>
<pre><code class="lang-perl">while (my @gr = getgrent()) {
p "$gr[0]: gid=$gr[2] members=$gr[3]"
}
endgrent()
</code></pre>
</article>
<article class="doc-entry" id="doc-getppid">
<h3><a class="doc-anchor" href="#doc-getppid">#</a> <code>getppid</code></h3>
<p>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>
<pre><code class="lang-perl">p "my pid: $$, parent: " . getppid()
if (getppid() == 1) {
log_warn("parent process has exited, we are orphaned")
}
</code></pre>
</article>
<article class="doc-entry" id="doc-getpgrp">
<h3><a class="doc-anchor" href="#doc-getpgrp">#</a> <code>getpgrp</code></h3>
<p>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 <code>setpgrp</code> to move a process into a different group.</p>
<pre><code class="lang-perl">p "process group: " . getpgrp()
my $pg = getpgrp($$)
p $pg == $$ ? "group leader" : "group member"
</code></pre>
</article>
<article class="doc-entry" id="doc-setpgrp">
<h3><a class="doc-anchor" href="#doc-setpgrp">#</a> <code>setpgrp</code></h3>
<p>Set the process group ID of a process. Call <code>setpgrp(0, 0)</code> 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 <code>(PID, PGID)</code> — use <code>0</code> for the current process.</p>
<pre><code class="lang-perl">setpgrp(0, 0) # become process group leader
if (fork() == 0) {
setpgrp(0, 0) # child gets its own group
exec("worker")
}
</code></pre>
</article>
<article class="doc-entry" id="doc-getpriority">
<h3><a class="doc-anchor" href="#doc-getpriority">#</a> <code>getpriority</code></h3>
<p>Get the scheduling priority (nice value) of a process, process group, or user. The <code>which</code> argument selects the target type: <code>PRIO_PROCESS</code>, <code>PRIO_PGRP</code>, or <code>PRIO_USER</code>. Lower values mean higher priority. The default nice value is <code>0</code>; range is typically <code>-20</code> to <code>19</code>.</p>
<pre><code class="lang-perl">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"
</code></pre>
</article>
<article class="doc-entry" id="doc-setpriority">
<h3><a class="doc-anchor" href="#doc-setpriority">#</a> <code>setpriority</code></h3>
<p>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.</p>
<pre><code class="lang-perl">setpriority(0, $$, 10) # lower priority for batch work
if (fork() == 0) {
setpriority(0, 0, 19) # lowest priority for child
exec("batch-job")
}
</code></pre>
</article>
<article class="doc-entry" id="doc-syscall">
<h3><a class="doc-anchor" href="#doc-syscall">#</a> <code>syscall</code></h3>
<p>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.</p>
<pre><code class="lang-perl"># 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
</code></pre>
</article>
<article class="doc-entry" id="doc-process-list">
<h3><a class="doc-anchor" href="#doc-process-list">#</a> <code>process_list</code></h3>
<p><code>process_list</code> (aliases <code>ps</code>, <code>procs</code>) — list running processes as an array of hashrefs with <code>{pid, name, uid}</code> keys.</p>
<pre><code class="lang-perl">my @procs = ps()
for (@procs) { p "$_->{pid} $_->{name}" }
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-pack-binary">
<h2>Pack / Binary</h2>
<p class="chapter-meta">3 topics</p>
<article class="doc-entry" id="doc-pack">
<h3><a class="doc-anchor" href="#doc-pack">#</a> <code>pack</code></h3>
<p>Convert a list of values into a binary string according to a template. Each template character specifies how one value is encoded: <code>N</code> for 32-bit big-endian unsigned, <code>n</code> for 16-bit, <code>a</code> for raw bytes, <code>Z</code> for null-terminated string, etc. This is essential for constructing binary protocols, file formats, and <code>sockaddr</code> structures.</p>
<pre><code class="lang-perl">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)
</code></pre>
</article>
<article class="doc-entry" id="doc-unpack">
<h3><a class="doc-anchor" href="#doc-unpack">#</a> <code>unpack</code></h3>
<p>Decode a binary string into a list of values according to a template, performing the inverse of <code>pack</code>. 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.</p>
<pre><code class="lang-perl">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"
</code></pre>
</article>
<article class="doc-entry" id="doc-vec">
<h3><a class="doc-anchor" href="#doc-vec">#</a> <code>vec</code></h3>
<p>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, <code>vec</code> modifies the string in place. Useful for compact boolean arrays and bitmap manipulation.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-logging">
<h2>Logging</h2>
<p class="chapter-meta">7 topics</p>
<article class="doc-entry" id="doc-log-info">
<h3><a class="doc-anchor" href="#doc-log-info">#</a> <code>log_info</code></h3>
<p>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.</p>
<pre><code class="lang-perl">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 $_") }
</code></pre>
</article>
<article class="doc-entry" id="doc-log-warn">
<h3><a class="doc-anchor" href="#doc-log-warn">#</a> <code>log_warn</code></h3>
<p>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.</p>
<pre><code class="lang-perl">log_warn("config file not found, using defaults")
log_warn("query took ${elapsed}s, exceeds threshold")
unless (-e $path) {
log_warn("$path missing, skipping")
}
</code></pre>
</article>
<article class="doc-entry" id="doc-log-error">
<h3><a class="doc-anchor" href="#doc-log-error">#</a> <code>log_error</code></h3>
<p>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.</p>
<pre><code class="lang-perl">log_error("failed to connect to $host: $!")
eval { rj("bad.json") }
log_error("parse failed: $@") if $@
log_error("missing required field 'name'")
</code></pre>
</article>
<article class="doc-entry" id="doc-log-debug">
<h3><a class="doc-anchor" href="#doc-log-debug">#</a> <code>log_debug</code></h3>
<p>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 <code>log_level</code>. Use for detailed internal state that helps during development — variable dumps, branch decisions, intermediate values.</p>
<pre><code class="lang-perl">log_level("debug")
log_debug("cache key: $key")
my $result = compute($x)
log_debug("compute($x) => $result")
@items |> e { log_debug("item: $_") }
</code></pre>
</article>
<article class="doc-entry" id="doc-log-trace">
<h3><a class="doc-anchor" href="#doc-log-trace">#</a> <code>log_trace</code></h3>
<p>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 <code>log_level("trace")</code> is set. Use sparingly in production code; primarily for deep debugging sessions.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-log-json">
<h3><a class="doc-anchor" href="#doc-log-json">#</a> <code>log_json</code></h3>
<p>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 <code>jq</code>-friendly output. Each call emits exactly one JSON object per line.</p>
<pre><code class="lang-perl">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.
</code></pre>
</article>
<article class="doc-entry" id="doc-log-level">
<h3><a class="doc-anchor" href="#doc-log-level">#</a> <code>log_level</code></h3>
<p>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: <code>trace</code>, <code>debug</code>, <code>info</code>, <code>warn</code>, <code>error</code>. The default level is <code>info</code>.</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-charts-svg">
<h2>Charts (SVG)</h2>
<p class="chapter-meta">19 topics</p>
<article class="doc-entry" id="doc-scatter-svg">
<h3><a class="doc-anchor" href="#doc-scatter-svg">#</a> <code>scatter_svg</code></h3>
<p><code>scatter_svg</code> (alias <code>scatter_plot</code>) — generate an SVG scatter plot. Args: xs, ys [, title]. Dark theme, auto-scaled axes.</p>
<pre><code class="lang-perl">scatter_svg([1,2,3,4], [1,4,9,16], "Squares") |> to_file("scatter.svg")
</code></pre>
</article>
<article class="doc-entry" id="doc-line-svg">
<h3><a class="doc-anchor" href="#doc-line-svg">#</a> <code>line_svg</code></h3>
<p><code>line_svg</code> (alias <code>line_plot</code>) — generate an SVG line plot. Args: xs, ys [, title].</p>
<pre><code class="lang-perl">my @x = map { $_ * 0.1 } 0..100
my @y = map { sin($_) } @x
line_svg(\@x, \@y, "Sine") |> to_file("sine.svg")
</code></pre>
</article>
<article class="doc-entry" id="doc-plot-svg">
<h3><a class="doc-anchor" href="#doc-plot-svg">#</a> <code>plot_svg</code></h3>
<p><code>plot_svg</code> — SVG line plot with auto X axis (0..n-1). Args: ys [, title].</p>
<pre><code class="lang-perl">plot_svg([map { $_ ** 2 } 0..50], "Parabola") |> to_file("plot.svg")
</code></pre>
</article>
<article class="doc-entry" id="doc-hist-svg">
<h3><a class="doc-anchor" href="#doc-hist-svg">#</a> <code>hist_svg</code></h3>
<p><code>hist_svg</code> (alias <code>histogram_svg</code>) — SVG histogram with auto-binning (sqrt rule). Args: data [, bins, title].</p>
<pre><code class="lang-perl">rnorm(1000) |> hist_svg(30, "Normal") |> to_file("hist.svg")
</code></pre>
</article>
<article class="doc-entry" id="doc-boxplot-svg">
<h3><a class="doc-anchor" href="#doc-boxplot-svg">#</a> <code>boxplot_svg</code></h3>
<p><code>boxplot_svg</code> (alias <code>box_plot</code>) — SVG box-and-whisker plot with IQR whiskers and outlier detection. Args: groups [, title]. Groups is array of arrays.</p>
<pre><code class="lang-perl">boxplot_svg([[1,2,3,4,5], [3,4,5,6,20]], "Compare") |> to_file("box.svg")
</code></pre>
</article>
<article class="doc-entry" id="doc-bar-svg">
<h3><a class="doc-anchor" href="#doc-bar-svg">#</a> <code>bar_svg</code></h3>
<p><code>bar_svg</code> (alias <code>barchart_svg</code>) — SVG bar chart with labeled bars and value annotations. Args: labels, values [, title].</p>
<pre><code class="lang-perl">bar_svg(["Rust","Go","C++"], [45,30,25], "Languages") |> to_file("bar.svg")
</code></pre>
</article>
<article class="doc-entry" id="doc-pie-svg">
<h3><a class="doc-anchor" href="#doc-pie-svg">#</a> <code>pie_svg</code></h3>
<p><code>pie_svg</code> (alias <code>pie_chart</code>) — SVG pie chart with percentage labels. Args: labels, values [, title].</p>
<pre><code class="lang-perl">pie_svg(["A","B","C"], [50,30,20]) |> to_file("pie.svg")
</code></pre>
</article>
<article class="doc-entry" id="doc-heatmap-svg">
<h3><a class="doc-anchor" href="#doc-heatmap-svg">#</a> <code>heatmap_svg</code></h3>
<p><code>heatmap_svg</code> (alias <code>heatmap</code>) — SVG heatmap with blue-cyan-yellow-red colormap. Args: matrix [, title].</p>
<pre><code class="lang-perl">heatmap_svg(cor_mat($data), "Correlation") |> to_file("heat.svg")
</code></pre>
</article>
<article class="doc-entry" id="doc-donut-svg">
<h3><a class="doc-anchor" href="#doc-donut-svg">#</a> <code>donut_svg</code></h3>
<p><code>donut_svg</code> (alias <code>donut</code>) — SVG donut chart with percentage labels. Accepts labels+values or a hashref.</p>
<pre><code class="lang-perl">donut_svg(["A","B","C"], [50,30,20], "Share") |> to_file("donut.svg")
{Rust => 45, Go => 30} |> donut("Languages") |> to_file("donut.svg")
</code></pre>
</article>
<article class="doc-entry" id="doc-area-svg">
<h3><a class="doc-anchor" href="#doc-area-svg">#</a> <code>area_svg</code></h3>
<p><code>area_svg</code> (alias <code>area_chart</code>) — SVG filled area chart. Args: xs, ys [, title].</p>
<pre><code class="lang-perl">my @x = 0..20
my @y = map { sin($_ * 0.3) } @x
area_svg(\@x, \@y, "Wave") |> to_file("area.svg")
</code></pre>
</article>
<article class="doc-entry" id="doc-hbar-svg">
<h3><a class="doc-anchor" href="#doc-hbar-svg">#</a> <code>hbar_svg</code></h3>
<p><code>hbar_svg</code> (alias <code>hbar</code>) — SVG horizontal bar chart. Accepts labels+values or a hashref.</p>
<pre><code class="lang-perl">hbar_svg(["Rust","Go","C++"], [45,30,25], "Speed") |> to_file("hbar.svg")
{alpha => 10, beta => 20} |> hbar |> to_file("hbar.svg")
</code></pre>
</article>
<article class="doc-entry" id="doc-radar-svg">
<h3><a class="doc-anchor" href="#doc-radar-svg">#</a> <code>radar_svg</code></h3>
<p><code>radar_svg</code> (aliases <code>radar</code>, <code>spider</code>) — SVG radar/spider chart. Args: labels, values [, title].</p>
<pre><code class="lang-perl">radar_svg(["Atk","Def","Spd","HP","MP"], [8,6,9,5,7], "Stats") |> to_file("radar.svg")
</code></pre>
</article>
<article class="doc-entry" id="doc-candlestick-svg">
<h3><a class="doc-anchor" href="#doc-candlestick-svg">#</a> <code>candlestick_svg</code></h3>
<p><code>candlestick_svg</code> (aliases <code>candlestick</code>, <code>ohlc</code>) — SVG candlestick OHLC chart. Args: array of [open,high,low,close] [, title].</p>
<pre><code class="lang-perl">candlestick_svg([[100,110,95,105],[105,115,100,112]], "Stock") |> to_file("ohlc.svg")
</code></pre>
</article>
<article class="doc-entry" id="doc-violin-svg">
<h3><a class="doc-anchor" href="#doc-violin-svg">#</a> <code>violin_svg</code></h3>
<p><code>violin_svg</code> (alias <code>violin</code>) — SVG violin plot from array of arrays showing distribution shape.</p>
<pre><code class="lang-perl">violin_svg([rnorm(200), rnorm(200, 2)], "Distributions") |> to_file("violin.svg")
</code></pre>
</article>
<article class="doc-entry" id="doc-cor-heatmap">
<h3><a class="doc-anchor" href="#doc-cor-heatmap">#</a> <code>cor_heatmap</code></h3>
<p><code>cor_heatmap</code> (alias <code>cor_matrix_svg</code>) — SVG correlation matrix heatmap. Computes pairwise correlations and renders as heatmap.</p>
<pre><code class="lang-perl">cor_heatmap([rnorm(100), rnorm(100), rnorm(100)], "Correlations") |> to_file("cor.svg")
</code></pre>
</article>
<article class="doc-entry" id="doc-stacked-bar-svg">
<h3><a class="doc-anchor" href="#doc-stacked-bar-svg">#</a> <code>stacked_bar_svg</code></h3>
<p><code>stacked_bar_svg</code> (alias <code>stacked_bar</code>) — SVG stacked bar chart. Args: labels, series (array of arrays) [, title].</p>
<pre><code class="lang-perl">stacked_bar_svg(["Q1","Q2","Q3"], [[10,20,30],[5,15,25]], "Revenue") |> to_file("stacked.svg")
</code></pre>
</article>
<article class="doc-entry" id="doc-wordcloud-svg">
<h3><a class="doc-anchor" href="#doc-wordcloud-svg">#</a> <code>wordcloud_svg</code></h3>
<p><code>wordcloud_svg</code> (aliases <code>wordcloud</code>, <code>wcloud</code>) — SVG word cloud from frequency hashref. Word size scales with frequency.</p>
<pre><code class="lang-perl">{rust => 50, go => 30, python => 40} |> wordcloud("Languages") |> to_file("cloud.svg")
</code></pre>
</article>
<article class="doc-entry" id="doc-treemap-svg">
<h3><a class="doc-anchor" href="#doc-treemap-svg">#</a> <code>treemap_svg</code></h3>
<p><code>treemap_svg</code> (alias <code>treemap</code>) — SVG treemap from frequency hashref. Area proportional to values.</p>
<pre><code class="lang-perl">{src => 500, tests => 200, docs => 100} |> treemap("Codebase") |> to_file("tree.svg")
</code></pre>
</article>
<article class="doc-entry" id="doc-preview">
<h3><a class="doc-anchor" href="#doc-preview">#</a> <code>preview</code></h3>
<p><code>preview</code> (alias <code>pvw</code>) — wrap SVG/HTML content in a cyberpunk-styled page and open in the default browser.</p>
<pre><code class="lang-perl">scatter_svg([1,2,3], [1,4,9]) |> preview
bar_svg(["A","B"], [10,20]) |> pvw
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-audio">
<h2>Audio</h2>
<p class="chapter-meta">4 topics</p>
<article class="doc-entry" id="doc-audio-convert">
<h3><a class="doc-anchor" href="#doc-audio-convert">#</a> <code>audio_convert</code></h3>
<p><code>audio_convert</code> (alias <code>aconv</code>) — convert audio files between WAV, FLAC, AIFF, and MP3 formats.</p>
<pre><code class="lang-perl">audio_convert("song.flac", "song.mp3")
aconv("input.wav", "output.mp3")
</code></pre>
</article>
<article class="doc-entry" id="doc-audio-info">
<h3><a class="doc-anchor" href="#doc-audio-info">#</a> <code>audio_info</code></h3>
<p><code>audio_info</code> (alias <code>ainfo</code>) — get audio file metadata (duration, sample rate, channels, format) as a hashref.</p>
<pre><code class="lang-perl">my $info = ainfo("song.mp3")
p $info->{duration} # seconds
p $info->{sample_rate} # e.g. 44100
</code></pre>
</article>
<article class="doc-entry" id="doc-id3-read">
<h3><a class="doc-anchor" href="#doc-id3-read">#</a> <code>id3_read</code></h3>
<p><code>id3_read</code> (alias <code>id3</code>) — read ID3 tags from an MP3 file as a hashref (title, artist, album, year, etc.).</p>
<pre><code class="lang-perl">my $tags = id3("song.mp3")
p "$tags->{artist} - $tags->{title}"
</code></pre>
</article>
<article class="doc-entry" id="doc-id3-write">
<h3><a class="doc-anchor" href="#doc-id3-write">#</a> <code>id3_write</code></h3>
<p><code>id3_write</code> (alias <code>id3w</code>) — write ID3 tags to an MP3 file from a hashref.</p>
<pre><code class="lang-perl">id3w("song.mp3", {title => "New Title", artist => "Artist", year => "2026"})
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-network-utilities">
<h2>Network Utilities</h2>
<p class="chapter-meta">18 topics</p>
<article class="doc-entry" id="doc-net-interfaces">
<h3><a class="doc-anchor" href="#doc-net-interfaces">#</a> <code>net_interfaces</code></h3>
<p><code>net_interfaces</code> (aliases <code>net_ifs</code>, <code>ifconfig</code>) — list all network interfaces with name, IPs, MAC, and status.</p>
<pre><code class="lang-perl">my @ifs = net_ifs()
for (@ifs) { p "$_->{name}: $_->{ipv4}" }
</code></pre>
</article>
<article class="doc-entry" id="doc-net-ipv4">
<h3><a class="doc-anchor" href="#doc-net-ipv4">#</a> <code>net_ipv4</code></h3>
<p><code>net_ipv4</code> (aliases <code>myip</code>, <code>myip4</code>) — return the first non-loopback IPv4 address as a string.</p>
<pre><code class="lang-perl">p myip() # e.g. 192.168.1.42
</code></pre>
</article>
<article class="doc-entry" id="doc-net-ipv6">
<h3><a class="doc-anchor" href="#doc-net-ipv6">#</a> <code>net_ipv6</code></h3>
<p><code>net_ipv6</code> (alias <code>myip6</code>) — return the first non-loopback IPv6 address as a string.</p>
<pre><code class="lang-perl">p myip6() # e.g. fe80::1
</code></pre>
</article>
<article class="doc-entry" id="doc-net-mac">
<h3><a class="doc-anchor" href="#doc-net-mac">#</a> <code>net_mac</code></h3>
<p><code>net_mac</code> (alias <code>mymac</code>) — return the first non-loopback MAC address.</p>
<pre><code class="lang-perl">p mymac() # e.g. aa:bb:cc:dd:ee:ff
</code></pre>
</article>
<article class="doc-entry" id="doc-net-public-ip">
<h3><a class="doc-anchor" href="#doc-net-public-ip">#</a> <code>net_public_ip</code></h3>
<p><code>net_public_ip</code> (aliases <code>pubip</code>, <code>extip</code>) — fetch your public IP address via HTTP.</p>
<pre><code class="lang-perl">p pubip() # e.g. 203.0.113.42
</code></pre>
</article>
<article class="doc-entry" id="doc-net-dns">
<h3><a class="doc-anchor" href="#doc-net-dns">#</a> <code>net_dns</code></h3>
<p><code>net_dns</code> (aliases <code>dns_resolve</code>, <code>resolve</code>) — resolve a hostname to IP addresses.</p>
<pre><code class="lang-perl">my @ips = resolve("github.com")
p @ips
</code></pre>
</article>
<article class="doc-entry" id="doc-net-reverse-dns">
<h3><a class="doc-anchor" href="#doc-net-reverse-dns">#</a> <code>net_reverse_dns</code></h3>
<p><code>net_reverse_dns</code> (alias <code>rdns</code>) — reverse DNS lookup via UDP PTR query.</p>
<pre><code class="lang-perl">p rdns("8.8.8.8") # dns.google
</code></pre>
</article>
<article class="doc-entry" id="doc-net-ping">
<h3><a class="doc-anchor" href="#doc-net-ping">#</a> <code>net_ping</code></h3>
<p><code>net_ping</code> (alias <code>ping</code>) — TCP connect ping to host:port. Returns array of RTT measurements in ms.</p>
<pre><code class="lang-perl">my @rtt = ping("google.com", 443, 5) # 5 pings
p mean(@rtt)
</code></pre>
</article>
<article class="doc-entry" id="doc-net-port-open">
<h3><a class="doc-anchor" href="#doc-net-port-open">#</a> <code>net_port_open</code></h3>
<p><code>net_port_open</code> (alias <code>port_open</code>) — check if a TCP port is open on a host. Returns boolean.</p>
<pre><code class="lang-perl">p port_open("localhost", 8080) # 1 or 0
</code></pre>
</article>
<article class="doc-entry" id="doc-net-ports-scan">
<h3><a class="doc-anchor" href="#doc-net-ports-scan">#</a> <code>net_ports_scan</code></h3>
<p><code>net_ports_scan</code> (aliases <code>port_scan</code>, <code>portscan</code>) — scan a range of TCP ports on a host. Returns list of open ports.</p>
<pre><code class="lang-perl">my @open = port_scan("localhost", 80, 443)
p @open # e.g. 80, 443
</code></pre>
</article>
<article class="doc-entry" id="doc-net-latency">
<h3><a class="doc-anchor" href="#doc-net-latency">#</a> <code>net_latency</code></h3>
<p><code>net_latency</code> (alias <code>tcplat</code>) — measure TCP connect latency to host:port in milliseconds.</p>
<pre><code class="lang-perl">p tcplat("google.com", 443) # e.g. 12.5
</code></pre>
</article>
<article class="doc-entry" id="doc-net-download">
<h3><a class="doc-anchor" href="#doc-net-download">#</a> <code>net_download</code></h3>
<p><code>net_download</code> (aliases <code>download</code>, <code>wget</code>) — download a URL to a local file via ureq.</p>
<pre><code class="lang-perl">wget("https://example.com/data.csv", "data.csv")
</code></pre>
</article>
<article class="doc-entry" id="doc-net-headers">
<h3><a class="doc-anchor" href="#doc-net-headers">#</a> <code>net_headers</code></h3>
<p><code>net_headers</code> (alias <code>http_headers</code>) — fetch HTTP response headers as a hashref.</p>
<pre><code class="lang-perl">my $h = http_headers("https://example.com")
p $h->{"content-type"}
</code></pre>
</article>
<article class="doc-entry" id="doc-net-dns-servers">
<h3><a class="doc-anchor" href="#doc-net-dns-servers">#</a> <code>net_dns_servers</code></h3>
<p><code>net_dns_servers</code> (alias <code>dns_servers</code>) — return the system's configured DNS server addresses.</p>
<pre><code class="lang-perl">my @dns = dns_servers()
p @dns # e.g. 8.8.8.8, 8.8.4.4
</code></pre>
</article>
<article class="doc-entry" id="doc-net-gateway">
<h3><a class="doc-anchor" href="#doc-net-gateway">#</a> <code>net_gateway</code></h3>
<p><code>net_gateway</code> (alias <code>gateway</code>) — return the default gateway IP address.</p>
<pre><code class="lang-perl">p gateway() # e.g. 192.168.1.1
</code></pre>
</article>
<article class="doc-entry" id="doc-net-whois">
<h3><a class="doc-anchor" href="#doc-net-whois">#</a> <code>net_whois</code></h3>
<p><code>net_whois</code> (alias <code>whois</code>) — WHOIS lookup via raw TCP connection on port 43.</p>
<pre><code class="lang-perl">p whois("example.com")
</code></pre>
</article>
<article class="doc-entry" id="doc-net-hostname">
<h3><a class="doc-anchor" href="#doc-net-hostname">#</a> <code>net_hostname</code></h3>
<p><code>net_hostname</code> — return the system hostname.</p>
<pre><code class="lang-perl">p net_hostname() # e.g. my-macbook.local
</code></pre>
</article>
<article class="doc-entry" id="doc-smtp-send">
<h3><a class="doc-anchor" href="#doc-smtp-send">#</a> <code>smtp_send</code></h3>
<p><code>smtp_send</code> (aliases <code>send_email</code>, <code>email</code>) — send an email via SMTP with TLS. Takes a hashref with to, from, subject, body, and SMTP connection fields.</p>
<pre><code class="lang-perl">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})
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-markup-web-scraping">
<h2>Markup / Web Scraping</h2>
<p class="chapter-meta">4 topics</p>
<article class="doc-entry" id="doc-html-parse">
<h3><a class="doc-anchor" href="#doc-html-parse">#</a> <code>html_parse</code></h3>
<p><code>html_parse</code> (alias <code>parse_html</code>) — parse an HTML string into an array of element hashrefs with tag, text, and attrs.</p>
<pre><code class="lang-perl">my @els = html_parse(slurp("page.html"))
for (@els) { p "$_->{tag}: $_->{text}" }
</code></pre>
</article>
<article class="doc-entry" id="doc-css-select">
<h3><a class="doc-anchor" href="#doc-css-select">#</a> <code>css_select</code></h3>
<p><code>css_select</code> (aliases <code>css</code>, <code>qs</code>, <code>query_selector</code>) — query parsed HTML with a CSS selector. Returns matching elements as hashrefs with tag, text, attrs, and html.</p>
<pre><code class="lang-perl">my @links = css_select(slurp("page.html"), "a.nav")
for (@links) { p "$_->{tag} $_->{attrs}{href}" }
</code></pre>
</article>
<article class="doc-entry" id="doc-xml-parse">
<h3><a class="doc-anchor" href="#doc-xml-parse">#</a> <code>xml_parse</code></h3>
<p><code>xml_parse</code> (alias <code>parse_xml</code>) — parse an XML string into a nested hashref tree with tag, text, attrs, and children.</p>
<pre><code class="lang-perl">my $root = xml_parse(slurp("data.xml"))
p $root->{tag}
for (@{$root->{children}}) { p $_->{text} }
</code></pre>
</article>
<article class="doc-entry" id="doc-xpath">
<h3><a class="doc-anchor" href="#doc-xpath">#</a> <code>xpath</code></h3>
<p><code>xpath</code> (alias <code>xml_select</code>) — query XML with XPath-like expressions (//tag, //tag[@attr='val']). Returns matching nodes as hashrefs.</p>
<pre><code class="lang-perl">my @items = xpath(slurp("feed.xml"), "//item")
for (@items) { p $_->{text} }
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-date-utilities">
<h2>Date Utilities</h2>
<p class="chapter-meta">4 topics</p>
<article class="doc-entry" id="doc-dateseq">
<h3><a class="doc-anchor" href="#doc-dateseq">#</a> <code>dateseq</code></h3>
<p><code>dateseq</code> (alias <code>dseq</code>) — generate a sequence of dates. Args: start, end [, step]. Step defaults to 1 day.</p>
<pre><code class="lang-perl">my @days = dseq("2026-01-01", "2026-01-07")
p @days
</code></pre>
</article>
<article class="doc-entry" id="doc-dategrep">
<h3><a class="doc-anchor" href="#doc-dategrep">#</a> <code>dategrep</code></h3>
<p><code>dategrep</code> (alias <code>dgrep</code>) — filter a list of date strings by a pattern or range.</p>
<pre><code class="lang-perl">my @jan = dgrep("2026-01", @dates)
</code></pre>
</article>
<article class="doc-entry" id="doc-dateround">
<h3><a class="doc-anchor" href="#doc-dateround">#</a> <code>dateround</code></h3>
<p><code>dateround</code> (alias <code>dround</code>) — round date strings to a unit (day, hour, month, etc.).</p>
<pre><code class="lang-perl">p dround("2026-04-19T14:35:22", "hour") # 2026-04-19T15:00:00
</code></pre>
</article>
<article class="doc-entry" id="doc-datesort">
<h3><a class="doc-anchor" href="#doc-datesort">#</a> <code>datesort</code></h3>
<p><code>datesort</code> (alias <code>dsort</code>) — sort date strings chronologically.</p>
<pre><code class="lang-perl">my @sorted = dsort("2026-03-01", "2026-01-15", "2026-02-10")
p @sorted
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-git">
<h2>Git</h2>
<p class="chapter-meta">10 topics</p>
<article class="doc-entry" id="doc-git-log">
<h3><a class="doc-anchor" href="#doc-git-log">#</a> <code>git_log</code></h3>
<p><code>git_log</code> (alias <code>glog</code>) — get the last N commits as an array of hashrefs (hash, author, date, message).</p>
<pre><code class="lang-perl">my @commits = glog(10)
for (@commits) { p "$_->{hash} $_->{message}" }
</code></pre>
</article>
<article class="doc-entry" id="doc-git-status">
<h3><a class="doc-anchor" href="#doc-git-status">#</a> <code>git_status</code></h3>
<p><code>git_status</code> (alias <code>gst</code>) — get working tree status as an array of hashrefs (path, status).</p>
<pre><code class="lang-perl">my @st = gst()
for (@st) { p "$_->{status} $_->{path}" }
</code></pre>
</article>
<article class="doc-entry" id="doc-git-diff">
<h3><a class="doc-anchor" href="#doc-git-diff">#</a> <code>git_diff</code></h3>
<p><code>git_diff</code> (alias <code>gdiff</code>) — get the current diff as a string.</p>
<pre><code class="lang-perl">p gdiff()
gdiff() |> lines |> grep /^\+/ |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-git-branches">
<h3><a class="doc-anchor" href="#doc-git-branches">#</a> <code>git_branches</code></h3>
<p><code>git_branches</code> (alias <code>gbr</code>) — list all branches as an array of strings.</p>
<pre><code class="lang-perl">my @br = gbr()
p @br
</code></pre>
</article>
<article class="doc-entry" id="doc-git-tags">
<h3><a class="doc-anchor" href="#doc-git-tags">#</a> <code>git_tags</code></h3>
<p><code>git_tags</code> (alias <code>gtags</code>) — list all tags as an array of strings.</p>
<pre><code class="lang-perl">my @tags = gtags()
p @tags
</code></pre>
</article>
<article class="doc-entry" id="doc-git-blame">
<h3><a class="doc-anchor" href="#doc-git-blame">#</a> <code>git_blame</code></h3>
<p><code>git_blame</code> (alias <code>gblame</code>) — blame a file, returning per-line annotation.</p>
<pre><code class="lang-perl">p gblame("src/main.rs")
</code></pre>
</article>
<article class="doc-entry" id="doc-git-authors">
<h3><a class="doc-anchor" href="#doc-git-authors">#</a> <code>git_authors</code></h3>
<p><code>git_authors</code> (alias <code>gauthors</code>) — list unique authors sorted by commit count as hashrefs.</p>
<pre><code class="lang-perl">my @authors = gauthors()
for (@authors) { p "$_->{name}: $_->{count}" }
</code></pre>
</article>
<article class="doc-entry" id="doc-git-files">
<h3><a class="doc-anchor" href="#doc-git-files">#</a> <code>git_files</code></h3>
<p><code>git_files</code> (alias <code>gfiles</code>) — list all tracked files in the repo.</p>
<pre><code class="lang-perl">my @files = gfiles()
p scalar @files # total tracked files
</code></pre>
</article>
<article class="doc-entry" id="doc-git-show">
<h3><a class="doc-anchor" href="#doc-git-show">#</a> <code>git_show</code></h3>
<p><code>git_show</code> (alias <code>gshow</code>) — show details of a commit (message, diff, author).</p>
<pre><code class="lang-perl">p gshow("HEAD")
p gshow("abc1234")
</code></pre>
</article>
<article class="doc-entry" id="doc-git-root">
<h3><a class="doc-anchor" href="#doc-git-root">#</a> <code>git_root</code></h3>
<p><code>git_root</code> (alias <code>groot</code>) — return the repository root path.</p>
<pre><code class="lang-perl">p groot() # e.g. /home/user/project
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-system">
<h2>System</h2>
<p class="chapter-meta">8 topics</p>
<article class="doc-entry" id="doc-mounts">
<h3><a class="doc-anchor" href="#doc-mounts">#</a> <code>mounts</code></h3>
<p><code>mounts</code> (aliases <code>disk_mounts</code>, <code>filesystems</code>) — list mounted filesystems with usage (total, used, available).</p>
<pre><code class="lang-perl">my @m = mounts()
for (@m) { p "$_->{mount}: $_->{used}/$_->{total}" }
</code></pre>
</article>
<article class="doc-entry" id="doc-thread-count">
<h3><a class="doc-anchor" href="#doc-thread-count">#</a> <code>thread_count</code></h3>
<p><code>thread_count</code> (alias <code>nthreads</code>) — return the rayon thread pool size.</p>
<pre><code class="lang-perl">p nthreads() # e.g. 8
</code></pre>
</article>
<article class="doc-entry" id="doc-pool-info">
<h3><a class="doc-anchor" href="#doc-pool-info">#</a> <code>pool_info</code></h3>
<p><code>pool_info</code> (alias <code>par_info</code>) — return thread pool details as a hashref (threads, queued, active).</p>
<pre><code class="lang-perl">my $info = par_info()
p $info->{threads}
</code></pre>
</article>
<article class="doc-entry" id="doc-par-bench">
<h3><a class="doc-anchor" href="#doc-par-bench">#</a> <code>par_bench</code></h3>
<p><code>par_bench</code> (alias <code>pbench</code>) — run a parallel throughput benchmark and return results.</p>
<pre><code class="lang-perl">my $result = pbench(1000000)
p $result->{ops_per_sec}
</code></pre>
</article>
<article class="doc-entry" id="doc-to-pdf">
<h3><a class="doc-anchor" href="#doc-to-pdf">#</a> <code>to_pdf</code></h3>
<p><code>to_pdf</code> — generate a PDF from text, SVG, or structured data. Returns raw PDF bytes.</p>
<pre><code class="lang-perl">"Hello World" |> to_pdf |> to_file("out.pdf")
scatter_svg([1,2,3], [1,4,9]) |> to_pdf |> to_file("plot.pdf")
</code></pre>
</article>
<article class="doc-entry" id="doc-pdf-text">
<h3><a class="doc-anchor" href="#doc-pdf-text">#</a> <code>pdf_text</code></h3>
<p><code>pdf_text</code> (aliases <code>pdf_read</code>, <code>pdf_extract</code>) — extract all text content from a PDF file and return it as a string.</p>
<pre><code class="lang-perl">my $text = pdf_text("report.pdf")
p $text |> lines |> cnt # number of lines
</code></pre>
</article>
<article class="doc-entry" id="doc-pdf-pages">
<h3><a class="doc-anchor" href="#doc-pdf-pages">#</a> <code>pdf_pages</code></h3>
<p><code>pdf_pages</code> — return the number of pages in a PDF file.</p>
<pre><code class="lang-perl">p pdf_pages("report.pdf") # e.g. 42
</code></pre>
</article>
<article class="doc-entry" id="doc-jq">
<h3><a class="doc-anchor" href="#doc-jq">#</a> <code>jq</code></h3>
<p><code>jq</code> — alias for <code>json_jq</code>. Query JSON data with jq-style expressions.</p>
<pre><code class="lang-perl">my $data = json_decode(slurp("data.json"))
p jq($data, ".items[].name")
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-testing">
<h2>Testing</h2>
<p class="chapter-meta">15 topics</p>
<article class="doc-entry" id="doc-assert-eq">
<h3><a class="doc-anchor" href="#doc-assert-eq">#</a> <code>assert_eq</code></h3>
<p><code>assert_eq</code> (alias <code>aeq</code>) — 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.</p>
<pre><code class="lang-perl">assert_eq $got, $expected, "username matches"
aeq length(@arr), 3
</code></pre>
</article>
<article class="doc-entry" id="doc-assert-ne">
<h3><a class="doc-anchor" href="#doc-assert-ne">#</a> <code>assert_ne</code></h3>
<p><code>assert_ne</code> (alias <code>ane</code>) — assert that two values are not equal as strings. Takes A, B, and an optional message. Fails if A eq B.</p>
<pre><code class="lang-perl">assert_ne $token, "", "token must not be empty"
ane $a, $b
</code></pre>
</article>
<article class="doc-entry" id="doc-assert-ok">
<h3><a class="doc-anchor" href="#doc-assert-ok">#</a> <code>assert_ok</code></h3>
<p><code>assert_ok</code> (alias <code>aok</code>) — assert that a value is truthy (defined and non-zero/non-empty). Fails if the value is falsy or undef.</p>
<pre><code class="lang-perl">assert_ok $result, "fetch returned data"
aok $user->{active}
</code></pre>
</article>
<article class="doc-entry" id="doc-assert-err">
<h3><a class="doc-anchor" href="#doc-assert-err">#</a> <code>assert_err</code></h3>
<p><code>assert_err</code> — assert that a value is falsy or undef. The inverse of <code>assert_ok</code>. Useful for verifying error conditions or absent values.</p>
<pre><code class="lang-perl">assert_err $deleted_user, "user should be gone"
assert_err 0
</code></pre>
</article>
<article class="doc-entry" id="doc-assert-true">
<h3><a class="doc-anchor" href="#doc-assert-true">#</a> <code>assert_true</code></h3>
<p><code>assert_true</code> (alias <code>atrue</code>) — alias for <code>assert_ok</code>. Assert that a value is truthy.</p>
<pre><code class="lang-perl">assert_true $connected, "should be connected"
atrue $flag
</code></pre>
</article>
<article class="doc-entry" id="doc-assert-false">
<h3><a class="doc-anchor" href="#doc-assert-false">#</a> <code>assert_false</code></h3>
<p><code>assert_false</code> (alias <code>afalse</code>) — alias for <code>assert_err</code>. Assert that a value is falsy or undef.</p>
<pre><code class="lang-perl">assert_false $error, "no error expected"
afalse $disabled
</code></pre>
</article>
<article class="doc-entry" id="doc-assert-gt">
<h3><a class="doc-anchor" href="#doc-assert-gt">#</a> <code>assert_gt</code></h3>
<p><code>assert_gt</code> — assert that the first numeric value is strictly greater than the second. Fails with the actual values on mismatch.</p>
<pre><code class="lang-perl">assert_gt $elapsed, 0, "elapsed must be positive"
assert_gt scalar(@results), 10
</code></pre>
</article>
<article class="doc-entry" id="doc-assert-lt">
<h3><a class="doc-anchor" href="#doc-assert-lt">#</a> <code>assert_lt</code></h3>
<p><code>assert_lt</code> — assert that the first numeric value is strictly less than the second.</p>
<pre><code class="lang-perl">assert_lt $latency, 100, "latency under 100ms"
assert_lt $errors, $threshold
</code></pre>
</article>
<article class="doc-entry" id="doc-assert-ge">
<h3><a class="doc-anchor" href="#doc-assert-ge">#</a> <code>assert_ge</code></h3>
<p><code>assert_ge</code> — assert that the first numeric value is greater than or equal to the second.</p>
<pre><code class="lang-perl">assert_ge $count, 1, "at least one result"
assert_ge $version, 2
</code></pre>
</article>
<article class="doc-entry" id="doc-assert-le">
<h3><a class="doc-anchor" href="#doc-assert-le">#</a> <code>assert_le</code></h3>
<p><code>assert_le</code> — assert that the first numeric value is less than or equal to the second.</p>
<pre><code class="lang-perl">assert_le $memory, $limit, "within memory budget"
assert_le length($buf), 4096
</code></pre>
</article>
<article class="doc-entry" id="doc-assert-match">
<h3><a class="doc-anchor" href="#doc-assert-match">#</a> <code>assert_match</code></h3>
<p><code>assert_match</code> (alias <code>amatch</code>) — assert that a string matches a regex pattern. Fails with the actual string and pattern on mismatch.</p>
<pre><code class="lang-perl">assert_match $email, qr/\@/, "must contain @"
amatch $line, qr/^OK/
</code></pre>
</article>
<article class="doc-entry" id="doc-assert-contains">
<h3><a class="doc-anchor" href="#doc-assert-contains">#</a> <code>assert_contains</code></h3>
<p><code>assert_contains</code> (alias <code>acontains</code>) — assert that a string contains a given substring. Fails with both values on mismatch.</p>
<pre><code class="lang-perl">assert_contains $html, "<title>", "page has title"
acontains $log, "SUCCESS"
</code></pre>
</article>
<article class="doc-entry" id="doc-assert-near">
<h3><a class="doc-anchor" href="#doc-assert-near">#</a> <code>assert_near</code></h3>
<p><code>assert_near</code> (alias <code>anear</code>) — assert that two floats are approximately equal within an epsilon tolerance (default 1e-9). Essential for floating-point comparisons.</p>
<pre><code class="lang-perl">assert_near 0.1 + 0.2, 0.3, 1e-10, "float add"
anear $pi, 3.14159, 1e-5
</code></pre>
</article>
<article class="doc-entry" id="doc-assert-dies">
<h3><a class="doc-anchor" href="#doc-assert-dies">#</a> <code>assert_dies</code></h3>
<p><code>assert_dies</code> (alias <code>adies</code>) — assert that a block throws an error. Passes if the block dies, fails if it returns normally.</p>
<pre><code class="lang-perl">assert_dies { die "boom" } "should throw"
adies { 1 / 0 }
</code></pre>
</article>
<article class="doc-entry" id="doc-test-run">
<h3><a class="doc-anchor" href="#doc-test-run">#</a> <code>test_run</code></h3>
<p><code>test_run</code> (alias <code>run_tests</code>) — 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.</p>
<pre><code class="lang-perl"># ... assertions above ...
test_run # prints summary, exits 1 on failure
</code></pre>
</article>
</section>
<section class="tutorial-section" id="ch-other">
<h2>Other</h2>
<p class="chapter-meta">2603 topics</p>
<article class="doc-entry" id="doc-stryke-rust-compile">
<h3><a class="doc-anchor" href="#doc-stryke-rust-compile">#</a> <code>__stryke_rust_compile</code></h3>
<p><code>__stryke_rust_compile</code> — internal builtin.</p>
<pre><code class="lang-perl">my $result = __stryke_rust_compile $x
# or in a pipeline:
@list |> map __stryke_rust_compile |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-a0">
<h3><a class="doc-anchor" href="#doc-a0">#</a> <code>a0</code></h3>
<p><code>bohr_radius</code> (alias <code>a0</code>) — a₀ ≈ 5.29×10⁻¹¹ m. Radius of hydrogen atom ground state.</p>
<pre><code class="lang-perl">p a0 # 5.29177210903e-11
</code></pre>
</article>
<article class="doc-entry" id="doc-a256">
<h3><a class="doc-anchor" href="#doc-a256">#</a> <code>a256</code></h3>
<p><code>a256</code> — color operations builtin. Alias for <code>ansi_256</code>.</p>
<pre><code class="lang-perl">my $result = a256 $x
# or in a pipeline:
@list |> map a256 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-a85d">
<h3><a class="doc-anchor" href="#doc-a85d">#</a> <code>a85d</code></h3>
<p><code>base85_decode</code> (aliases <code>b85d</code>, <code>a85d</code>) decodes an Ascii85/Base85 encoded string.</p>
<pre><code class="lang-perl">p b85d(b85e("Hello")) # Hello
</code></pre>
</article>
<article class="doc-entry" id="doc-a85e">
<h3><a class="doc-anchor" href="#doc-a85e">#</a> <code>a85e</code></h3>
<p><code>base85_encode</code> (aliases <code>b85e</code>, <code>a85e</code>) encodes a string using Ascii85/Base85 encoding. More compact than Base64 (4:5 ratio vs 3:4).</p>
<pre><code class="lang-perl">p b85e("Hello") # encoded string
</code></pre>
</article>
<article class="doc-entry" id="doc-abs-ceil">
<h3><a class="doc-anchor" href="#doc-abs-ceil">#</a> <code>abs_ceil</code></h3>
<p><code>abs_ceil</code> — trivial numeric helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = abs_ceil $x
# or in a pipeline:
@list |> map abs_ceil |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-abs-diff">
<h3><a class="doc-anchor" href="#doc-abs-diff">#</a> <code>abs_diff</code></h3>
<p><code>abs_diff</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = abs_diff $x
# or in a pipeline:
@list |> map abs_diff |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-abs-each">
<h3><a class="doc-anchor" href="#doc-abs-each">#</a> <code>abs_each</code></h3>
<p><code>abs_each</code> — trivial numeric helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = abs_each $x
# or in a pipeline:
@list |> map abs_each |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-abs-floor">
<h3><a class="doc-anchor" href="#doc-abs-floor">#</a> <code>abs_floor</code></h3>
<p><code>abs_floor</code> — trivial numeric helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = abs_floor $x
# or in a pipeline:
@list |> map abs_floor |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-abundant-numbers">
<h3><a class="doc-anchor" href="#doc-abundant-numbers">#</a> <code>abundant_numbers</code></h3>
<p><code>abundant_numbers</code> — number theory / primes builtin.</p>
<pre><code class="lang-perl">my $result = abundant_numbers $x
# or in a pipeline:
@list |> map abundant_numbers |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-abunnums">
<h3><a class="doc-anchor" href="#doc-abunnums">#</a> <code>abunnums</code></h3>
<p><code>abunnums</code> — number theory / primes builtin. Alias for <code>abundant_numbers</code>.</p>
<pre><code class="lang-perl">my $result = abunnums $x
# or in a pipeline:
@list |> map abunnums |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-accum">
<h3><a class="doc-anchor" href="#doc-accum">#</a> <code>accum</code></h3>
<p><code>accum</code> — python/ruby stdlib builtin. Alias for <code>accumulate</code>.</p>
<pre><code class="lang-perl">my $result = accum $x
# or in a pipeline:
@list |> map accum |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-accumulate">
<h3><a class="doc-anchor" href="#doc-accumulate">#</a> <code>accumulate</code></h3>
<p><code>accumulate</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = accumulate $x
# or in a pipeline:
@list |> map accumulate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-acf">
<h3><a class="doc-anchor" href="#doc-acf">#</a> <code>acf</code></h3>
<p><code>acf_fn</code> (alias <code>acf</code>) — autocorrelation function. Returns ACF values for lags 0..max_lag. Like R's acf().</p>
<pre><code class="lang-perl">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
</code></pre>
</article>
<article class="doc-entry" id="doc-acirc">
<h3><a class="doc-anchor" href="#doc-acirc">#</a> <code>acirc</code></h3>
<p><code>acirc</code> — geometry / physics builtin. Alias for <code>area_circle</code>.</p>
<pre><code class="lang-perl">my $result = acirc $x
# or in a pipeline:
@list |> map acirc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-acorr">
<h3><a class="doc-anchor" href="#doc-acorr">#</a> <code>acorr</code></h3>
<p><code>acorr</code> — math / numeric (uncategorized batch) builtin. Alias for <code>autocorrelation</code>.</p>
<pre><code class="lang-perl">my $result = acorr $x
# or in a pipeline:
@list |> map acorr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-acos">
<h3><a class="doc-anchor" href="#doc-acos">#</a> <code>acos</code></h3>
<p><code>acos</code> — trig / math (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = acos $x
# or in a pipeline:
@list |> map acos |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-acosh">
<h3><a class="doc-anchor" href="#doc-acosh">#</a> <code>acosh</code></h3>
<p><code>acosh</code> — trig / math (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = acosh $x
# or in a pipeline:
@list |> map acosh |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-acot">
<h3><a class="doc-anchor" href="#doc-acot">#</a> <code>acot</code></h3>
<p><code>acot</code> — trig extensions builtin.</p>
<pre><code class="lang-perl">my $result = acot $x
# or in a pipeline:
@list |> map acot |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-acro">
<h3><a class="doc-anchor" href="#doc-acro">#</a> <code>acro</code></h3>
<p><code>acro</code> — string processing (uncategorized batch) builtin. Alias for <code>acronym</code>.</p>
<pre><code class="lang-perl">my $result = acro $x
# or in a pipeline:
@list |> map acro |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-acronym">
<h3><a class="doc-anchor" href="#doc-acronym">#</a> <code>acronym</code></h3>
<p><code>acronym</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = acronym $x
# or in a pipeline:
@list |> map acronym |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-acsc">
<h3><a class="doc-anchor" href="#doc-acsc">#</a> <code>acsc</code></h3>
<p><code>acsc</code> — trig extensions builtin.</p>
<pre><code class="lang-perl">my $result = acsc $x
# or in a pipeline:
@list |> map acsc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-add-days">
<h3><a class="doc-anchor" href="#doc-add-days">#</a> <code>add_days</code></h3>
<p><code>add_days</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = add_days $x
# or in a pipeline:
@list |> map add_days |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-add-hours">
<h3><a class="doc-anchor" href="#doc-add-hours">#</a> <code>add_hours</code></h3>
<p><code>add_hours</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = add_hours $x
# or in a pipeline:
@list |> map add_hours |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-add-minutes">
<h3><a class="doc-anchor" href="#doc-add-minutes">#</a> <code>add_minutes</code></h3>
<p><code>add_minutes</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = add_minutes $x
# or in a pipeline:
@list |> map add_minutes |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-addd">
<h3><a class="doc-anchor" href="#doc-addd">#</a> <code>addd</code></h3>
<p><code>addd</code> — extended stdlib builtin. Alias for <code>add_days</code>.</p>
<pre><code class="lang-perl">my $result = addd $x
# or in a pipeline:
@list |> map addd |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-addh">
<h3><a class="doc-anchor" href="#doc-addh">#</a> <code>addh</code></h3>
<p><code>addh</code> — extended stdlib builtin. Alias for <code>add_hours</code>.</p>
<pre><code class="lang-perl">my $result = addh $x
# or in a pipeline:
@list |> map addh |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-addm">
<h3><a class="doc-anchor" href="#doc-addm">#</a> <code>addm</code></h3>
<p><code>addm</code> — extended stdlib builtin. Alias for <code>add_minutes</code>.</p>
<pre><code class="lang-perl">my $result = addm $x
# or in a pipeline:
@list |> map addm |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-adjacent-difference">
<h3><a class="doc-anchor" href="#doc-adjacent-difference">#</a> <code>adjacent_difference</code></h3>
<p><code>adjacent_difference</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = adjacent_difference $x
# or in a pipeline:
@list |> map adjacent_difference |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-adjacent-pairs">
<h3><a class="doc-anchor" href="#doc-adjacent-pairs">#</a> <code>adjacent_pairs</code></h3>
<p><code>adjacent_pairs</code> — go/general functional utilities builtin.</p>
<pre><code class="lang-perl">my $result = adjacent_pairs $x
# or in a pipeline:
@list |> map adjacent_pairs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-adjp">
<h3><a class="doc-anchor" href="#doc-adjp">#</a> <code>adjp</code></h3>
<p><code>adjp</code> — go/general functional utilities builtin. Alias for <code>adjacent_pairs</code>.</p>
<pre><code class="lang-perl">my $result = adjp $x
# or in a pipeline:
@list |> map adjp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-adl32">
<h3><a class="doc-anchor" href="#doc-adl32">#</a> <code>adl32</code></h3>
<p><code>adl32</code> — extended stdlib builtin. Alias for <code>adler32</code>.</p>
<pre><code class="lang-perl">my $result = adl32 $x
# or in a pipeline:
@list |> map adl32 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-adler32">
<h3><a class="doc-anchor" href="#doc-adler32">#</a> <code>adler32</code></h3>
<p><code>adler32</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = adler32 $x
# or in a pipeline:
@list |> map adler32 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-aellip">
<h3><a class="doc-anchor" href="#doc-aellip">#</a> <code>aellip</code></h3>
<p><code>aellip</code> — geometry / physics builtin. Alias for <code>area_ellipse</code>.</p>
<pre><code class="lang-perl">my $result = aellip $x
# or in a pipeline:
@list |> map aellip |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-after-n">
<h3><a class="doc-anchor" href="#doc-after-n">#</a> <code>after_n</code></h3>
<p><code>after_n</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = after_n $x
# or in a pipeline:
@list |> map after_n |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-age-in-years">
<h3><a class="doc-anchor" href="#doc-age-in-years">#</a> <code>age_in_years</code></h3>
<p><code>age_in_years</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = age_in_years $x
# or in a pipeline:
@list |> map age_in_years |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ageyrs">
<h3><a class="doc-anchor" href="#doc-ageyrs">#</a> <code>ageyrs</code></h3>
<p><code>ageyrs</code> — extended stdlib batch 3 builtin. Alias for <code>age_in_years</code>.</p>
<pre><code class="lang-perl">my $result = ageyrs $x
# or in a pipeline:
@list |> map ageyrs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ain">
<h3><a class="doc-anchor" href="#doc-ain">#</a> <code>ain</code></h3>
<p><code>ain</code> — algebraic match builtin. Alias for <code>assoc_in</code>.</p>
<pre><code class="lang-perl">my $result = ain $x
# or in a pipeline:
@list |> map ain |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-aliquot">
<h3><a class="doc-anchor" href="#doc-aliquot">#</a> <code>aliquot</code></h3>
<p><code>aliquot</code> — math / numeric (uncategorized batch) builtin. Alias for <code>aliquot_sum</code>.</p>
<pre><code class="lang-perl">my $result = aliquot $x
# or in a pipeline:
@list |> map aliquot |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-aliquot-sum">
<h3><a class="doc-anchor" href="#doc-aliquot-sum">#</a> <code>aliquot_sum</code></h3>
<p><code>aliquot_sum</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = aliquot_sum $x
# or in a pipeline:
@list |> map aliquot_sum |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-all-distinct">
<h3><a class="doc-anchor" href="#doc-all-distinct">#</a> <code>all_distinct</code></h3>
<p><code>all_distinct</code> — more list helpers builtin.</p>
<pre><code class="lang-perl">my $result = all_distinct $x
# or in a pipeline:
@list |> map all_distinct |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-all-eq">
<h3><a class="doc-anchor" href="#doc-all-eq">#</a> <code>all_eq</code></h3>
<p><code>all_eq</code> — more list helpers builtin.</p>
<pre><code class="lang-perl">my $result = all_eq $x
# or in a pipeline:
@list |> map all_eq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-all-match">
<h3><a class="doc-anchor" href="#doc-all-match">#</a> <code>all_match</code></h3>
<p><code>all_match</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = all_match $x
# or in a pipeline:
@list |> map all_match |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-all-unique">
<h3><a class="doc-anchor" href="#doc-all-unique">#</a> <code>all_unique</code></h3>
<p><code>all_unique</code> — more list helpers builtin. Alias for <code>all_distinct</code>.</p>
<pre><code class="lang-perl">my $result = all_unique $x
# or in a pipeline:
@list |> map all_unique |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-alpha-fs">
<h3><a class="doc-anchor" href="#doc-alpha-fs">#</a> <code>alpha_fs</code></h3>
<p><code>fine_structure_constant</code> (alias <code>alpha_fs</code>) — α ≈ 1/137 ≈ 0.00730. Fundamental constant of electromagnetism.</p>
<pre><code class="lang-perl">p alpha_fs # 0.0072973525693
p 1 / alpha_fs # ~137.036
</code></pre>
</article>
<article class="doc-entry" id="doc-alternate-case">
<h3><a class="doc-anchor" href="#doc-alternate-case">#</a> <code>alternate_case</code></h3>
<p><code>alternate_case</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = alternate_case $x
# or in a pipeline:
@list |> map alternate_case |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-always-false">
<h3><a class="doc-anchor" href="#doc-always-false">#</a> <code>always_false</code></h3>
<p><code>always_false</code> — functional primitives builtin.</p>
<pre><code class="lang-perl">my $result = always_false $x
# or in a pipeline:
@list |> map always_false |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-always-true">
<h3><a class="doc-anchor" href="#doc-always-true">#</a> <code>always_true</code></h3>
<p><code>always_true</code> — functional primitives builtin.</p>
<pre><code class="lang-perl">my $result = always_true $x
# or in a pipeline:
@list |> map always_true |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-amax">
<h3><a class="doc-anchor" href="#doc-amax">#</a> <code>amax</code></h3>
<p><code>amax</code> — extended stdlib builtin. Alias for <code>argmax</code>.</p>
<pre><code class="lang-perl">my $result = amax $x
# or in a pipeline:
@list |> map amax |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-amin">
<h3><a class="doc-anchor" href="#doc-amin">#</a> <code>amin</code></h3>
<p><code>amin</code> — extended stdlib builtin. Alias for <code>argmin</code>.</p>
<pre><code class="lang-perl">my $result = amin $x
# or in a pipeline:
@list |> map amin |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-amort">
<h3><a class="doc-anchor" href="#doc-amort">#</a> <code>amort</code></h3>
<p><code>amortization_schedule($principal, $rate, $periods)</code> (alias <code>amort</code>) — generates a full amortization schedule. Returns arrayref of hashrefs with period, payment, principal, interest, balance.</p>
<pre><code class="lang-perl">my $sched = amort(10000, 0.05, 12)
for my $row (@$sched) {
p "Period $row->{period}: bal=$row->{balance}"
}
</code></pre>
</article>
<article class="doc-entry" id="doc-amu">
<h3><a class="doc-anchor" href="#doc-amu">#</a> <code>amu</code></h3>
<p><code>amu</code> — physics constants builtin. Alias for <code>atomic_mass_unit</code>.</p>
<pre><code class="lang-perl">my $result = amu $x
# or in a pipeline:
@list |> map amu |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-and">
<h3><a class="doc-anchor" href="#doc-and">#</a> <code>and</code></h3>
<p><code>and</code> — control flow builtin.</p>
<pre><code class="lang-perl">my $result = and $x
# or in a pipeline:
@list |> map and |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-and-list">
<h3><a class="doc-anchor" href="#doc-and-list">#</a> <code>and_list</code></h3>
<p><code>and_list</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = and_list $x
# or in a pipeline:
@list |> map and_list |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-andl">
<h3><a class="doc-anchor" href="#doc-andl">#</a> <code>andl</code></h3>
<p><code>andl</code> — additional missing stdlib functions builtin. Alias for <code>and_list</code>.</p>
<pre><code class="lang-perl">my $result = andl $x
# or in a pipeline:
@list |> map andl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-angbet">
<h3><a class="doc-anchor" href="#doc-angbet">#</a> <code>angbet</code></h3>
<p><code>angbet</code> — geometry (extended) builtin. Alias for <code>angle_between</code>.</p>
<pre><code class="lang-perl">my $result = angbet $x
# or in a pipeline:
@list |> map angbet |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-angle-between">
<h3><a class="doc-anchor" href="#doc-angle-between">#</a> <code>angle_between</code></h3>
<p><code>angle_between($x1, $y1, $x2, $y2)</code> — computes the angle in radians between two 2D vectors from origin. Returns the angle using atan2.</p>
<pre><code class="lang-perl">my $angle = angle_between(1, 0, 0, 1)
p $angle # ~1.5708 (π/2 radians = 90°)
</code></pre>
</article>
<article class="doc-entry" id="doc-angle-between-deg">
<h3><a class="doc-anchor" href="#doc-angle-between-deg">#</a> <code>angle_between_deg</code></h3>
<p><code>angle_between_deg</code> — math functions builtin.</p>
<pre><code class="lang-perl">my $result = angle_between_deg $x
# or in a pipeline:
@list |> map angle_between_deg |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-angle-bracket">
<h3><a class="doc-anchor" href="#doc-angle-bracket">#</a> <code>angle_bracket</code></h3>
<p><code>angle_bracket</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = angle_bracket $x
# or in a pipeline:
@list |> map angle_bracket |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-angular-velocity">
<h3><a class="doc-anchor" href="#doc-angular-velocity">#</a> <code>angular_velocity</code></h3>
<p><code>angular_velocity</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = angular_velocity $x
# or in a pipeline:
@list |> map angular_velocity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-angvel">
<h3><a class="doc-anchor" href="#doc-angvel">#</a> <code>angvel</code></h3>
<p><code>angvel</code> — physics formulas builtin. Alias for <code>angular_velocity</code>.</p>
<pre><code class="lang-perl">my $result = angvel $x
# or in a pipeline:
@list |> map angvel |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-anova">
<h3><a class="doc-anchor" href="#doc-anova">#</a> <code>anova</code></h3>
<p><code>anova_oneway</code> (aliases <code>anova</code>, <code>anova1</code>) performs one-way ANOVA. Returns [F-statistic, df_between, df_within].</p>
<pre><code class="lang-perl">my ($F, $dfb, $dfw) = @{anova([1,2,3], [4,5,6], [7,8,9])}
</code></pre>
</article>
<article class="doc-entry" id="doc-ansi-256">
<h3><a class="doc-anchor" href="#doc-ansi-256">#</a> <code>ansi_256</code></h3>
<p><code>ansi_256</code> — color operations builtin.</p>
<pre><code class="lang-perl">my $result = ansi_256 $x
# or in a pipeline:
@list |> map ansi_256 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ansi-black">
<h3><a class="doc-anchor" href="#doc-ansi-black">#</a> <code>ansi_black</code></h3>
<p><code>ansi_black</code> — color / ansi builtin.</p>
<pre><code class="lang-perl">my $result = ansi_black $x
# or in a pipeline:
@list |> map ansi_black |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ansi-blue">
<h3><a class="doc-anchor" href="#doc-ansi-blue">#</a> <code>ansi_blue</code></h3>
<p><code>ansi_blue</code> — color / ansi builtin.</p>
<pre><code class="lang-perl">my $result = ansi_blue $x
# or in a pipeline:
@list |> map ansi_blue |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ansi-bold">
<h3><a class="doc-anchor" href="#doc-ansi-bold">#</a> <code>ansi_bold</code></h3>
<p><code>ansi_bold</code> — color / ansi builtin.</p>
<pre><code class="lang-perl">my $result = ansi_bold $x
# or in a pipeline:
@list |> map ansi_bold |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ansi-cyan">
<h3><a class="doc-anchor" href="#doc-ansi-cyan">#</a> <code>ansi_cyan</code></h3>
<p><code>ansi_cyan</code> — color / ansi builtin.</p>
<pre><code class="lang-perl">my $result = ansi_cyan $x
# or in a pipeline:
@list |> map ansi_cyan |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ansi-dim">
<h3><a class="doc-anchor" href="#doc-ansi-dim">#</a> <code>ansi_dim</code></h3>
<p><code>ansi_dim</code> — color / ansi builtin.</p>
<pre><code class="lang-perl">my $result = ansi_dim $x
# or in a pipeline:
@list |> map ansi_dim |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ansi-green">
<h3><a class="doc-anchor" href="#doc-ansi-green">#</a> <code>ansi_green</code></h3>
<p><code>ansi_green</code> — color / ansi builtin.</p>
<pre><code class="lang-perl">my $result = ansi_green $x
# or in a pipeline:
@list |> map ansi_green |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ansi-magenta">
<h3><a class="doc-anchor" href="#doc-ansi-magenta">#</a> <code>ansi_magenta</code></h3>
<p><code>ansi_magenta</code> — color / ansi builtin.</p>
<pre><code class="lang-perl">my $result = ansi_magenta $x
# or in a pipeline:
@list |> map ansi_magenta |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ansi-off">
<h3><a class="doc-anchor" href="#doc-ansi-off">#</a> <code>ansi_off</code></h3>
<p><code>ansi_off</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = ansi_off $x
# or in a pipeline:
@list |> map ansi_off |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ansi-red">
<h3><a class="doc-anchor" href="#doc-ansi-red">#</a> <code>ansi_red</code></h3>
<p><code>ansi_red</code> — color / ansi builtin.</p>
<pre><code class="lang-perl">my $result = ansi_red $x
# or in a pipeline:
@list |> map ansi_red |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ansi-reverse">
<h3><a class="doc-anchor" href="#doc-ansi-reverse">#</a> <code>ansi_reverse</code></h3>
<p><code>ansi_reverse</code> — color / ansi builtin.</p>
<pre><code class="lang-perl">my $result = ansi_reverse $x
# or in a pipeline:
@list |> map ansi_reverse |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ansi-truecolor">
<h3><a class="doc-anchor" href="#doc-ansi-truecolor">#</a> <code>ansi_truecolor</code></h3>
<p><code>ansi_truecolor</code> — color operations builtin.</p>
<pre><code class="lang-perl">my $result = ansi_truecolor $x
# or in a pipeline:
@list |> map ansi_truecolor |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ansi-underline">
<h3><a class="doc-anchor" href="#doc-ansi-underline">#</a> <code>ansi_underline</code></h3>
<p><code>ansi_underline</code> — color / ansi builtin.</p>
<pre><code class="lang-perl">my $result = ansi_underline $x
# or in a pipeline:
@list |> map ansi_underline |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ansi-white">
<h3><a class="doc-anchor" href="#doc-ansi-white">#</a> <code>ansi_white</code></h3>
<p><code>ansi_white</code> — color / ansi builtin.</p>
<pre><code class="lang-perl">my $result = ansi_white $x
# or in a pipeline:
@list |> map ansi_white |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ansi-yellow">
<h3><a class="doc-anchor" href="#doc-ansi-yellow">#</a> <code>ansi_yellow</code></h3>
<p><code>ansi_yellow</code> — color / ansi builtin.</p>
<pre><code class="lang-perl">my $result = ansi_yellow $x
# or in a pipeline:
@list |> map ansi_yellow |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-any-match">
<h3><a class="doc-anchor" href="#doc-any-match">#</a> <code>any_match</code></h3>
<p><code>any_match</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = any_match $x
# or in a pipeline:
@list |> map any_match |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-apery">
<h3><a class="doc-anchor" href="#doc-apery">#</a> <code>apery</code></h3>
<p><code>apery</code> — math constants builtin. Alias for <code>apery_constant</code>.</p>
<pre><code class="lang-perl">my $result = apery $x
# or in a pipeline:
@list |> map apery |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-apery-constant">
<h3><a class="doc-anchor" href="#doc-apery-constant">#</a> <code>apery_constant</code></h3>
<p><code>apery_constant</code> — math constants builtin.</p>
<pre><code class="lang-perl">my $result = apery_constant $x
# or in a pipeline:
@list |> map apery_constant |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-append-elem">
<h3><a class="doc-anchor" href="#doc-append-elem">#</a> <code>append_elem</code></h3>
<p><code>append_elem</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = append_elem $x
# or in a pipeline:
@list |> map append_elem |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-appl">
<h3><a class="doc-anchor" href="#doc-appl">#</a> <code>appl</code></h3>
<p><code>appl</code> — algebraic match builtin. Alias for <code>apply</code>.</p>
<pre><code class="lang-perl">my $result = appl $x
# or in a pipeline:
@list |> map appl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-apply">
<h3><a class="doc-anchor" href="#doc-apply">#</a> <code>apply</code></h3>
<p><code>apply</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = apply $x
# or in a pipeline:
@list |> map apply |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-apply-list">
<h3><a class="doc-anchor" href="#doc-apply-list">#</a> <code>apply_list</code></h3>
<p><code>apply_list</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = apply_list $x
# or in a pipeline:
@list |> map apply_list |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-apply-window">
<h3><a class="doc-anchor" href="#doc-apply-window">#</a> <code>apply_window</code></h3>
<p><code>apply_window(\@signal, \@window)</code> — element-wise multiplies signal by window function. Use before FFT to reduce spectral leakage.</p>
<pre><code class="lang-perl">my $w = hann(scalar @signal)
my $windowed = apply_window(\@signal, $w)
my $spectrum = dft($windowed)
</code></pre>
</article>
<article class="doc-entry" id="doc-applywin">
<h3><a class="doc-anchor" href="#doc-applywin">#</a> <code>applywin</code></h3>
<p><code>applywin</code> — dsp / signal (extended) builtin. Alias for <code>apply_window</code>.</p>
<pre><code class="lang-perl">my $result = applywin $x
# or in a pipeline:
@list |> map applywin |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-approx">
<h3><a class="doc-anchor" href="#doc-approx">#</a> <code>approx</code></h3>
<p><code>approx_fn</code> (alias <code>approx</code>) — piecewise linear interpolation at query points. Like R's approx().</p>
<pre><code class="lang-perl">my @y = @{approx([0,1,2], [0,10,0], [0.5, 1.0, 1.5])}
# [5, 10, 5]
</code></pre>
</article>
<article class="doc-entry" id="doc-approx-eq">
<h3><a class="doc-anchor" href="#doc-approx-eq">#</a> <code>approx_eq</code></h3>
<p><code>approx_eq</code> — math functions builtin.</p>
<pre><code class="lang-perl">my $result = approx_eq $x
# or in a pipeline:
@list |> map approx_eq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-apsp">
<h3><a class="doc-anchor" href="#doc-apsp">#</a> <code>apsp</code></h3>
<p><code>floyd_warshall</code> (aliases <code>floydwarshall</code>, <code>apsp</code>) computes all-pairs shortest paths. Takes a distance matrix (use Inf for no edge).</p>
<pre><code class="lang-perl">my $d = apsp([[0,3,1e18],[1e18,0,1],[1e18,1e18,0]])
</code></pre>
</article>
<article class="doc-entry" id="doc-arange">
<h3><a class="doc-anchor" href="#doc-arange">#</a> <code>arange</code></h3>
<p><code>arange</code> — matrix / linear algebra builtin.</p>
<pre><code class="lang-perl">my $result = arange $x
# or in a pipeline:
@list |> map arange |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-arc-length">
<h3><a class="doc-anchor" href="#doc-arc-length">#</a> <code>arc_length</code></h3>
<p><code>arc_length($radius, $theta)</code> — computes the arc length of a circular arc. Theta is the central angle in radians. Returns <code>radius * theta</code>.</p>
<pre><code class="lang-perl">p arc_length(10, 3.14159) # ~31.4 (half circle)
p arc_length(5, 1.57) # ~7.85 (quarter circle)
</code></pre>
</article>
<article class="doc-entry" id="doc-arclen">
<h3><a class="doc-anchor" href="#doc-arclen">#</a> <code>arclen</code></h3>
<p><code>arclen</code> — geometry (extended) builtin. Alias for <code>arc_length</code>.</p>
<pre><code class="lang-perl">my $result = arclen $x
# or in a pipeline:
@list |> map arclen |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-area-circle">
<h3><a class="doc-anchor" href="#doc-area-circle">#</a> <code>area_circle</code></h3>
<p><code>area_circle</code> — geometry / physics builtin.</p>
<pre><code class="lang-perl">my $result = area_circle $x
# or in a pipeline:
@list |> map area_circle |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-area-ellipse">
<h3><a class="doc-anchor" href="#doc-area-ellipse">#</a> <code>area_ellipse</code></h3>
<p><code>area_ellipse</code> — geometry / physics builtin.</p>
<pre><code class="lang-perl">my $result = area_ellipse $x
# or in a pipeline:
@list |> map area_ellipse |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-area-rectangle">
<h3><a class="doc-anchor" href="#doc-area-rectangle">#</a> <code>area_rectangle</code></h3>
<p><code>area_rectangle</code> — geometry / physics builtin.</p>
<pre><code class="lang-perl">my $result = area_rectangle $x
# or in a pipeline:
@list |> map area_rectangle |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-area-trapezoid">
<h3><a class="doc-anchor" href="#doc-area-trapezoid">#</a> <code>area_trapezoid</code></h3>
<p><code>area_trapezoid</code> — geometry / physics builtin.</p>
<pre><code class="lang-perl">my $result = area_trapezoid $x
# or in a pipeline:
@list |> map area_trapezoid |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-area-triangle">
<h3><a class="doc-anchor" href="#doc-area-triangle">#</a> <code>area_triangle</code></h3>
<p><code>area_triangle</code> — geometry / physics builtin.</p>
<pre><code class="lang-perl">my $result = area_triangle $x
# or in a pipeline:
@list |> map area_triangle |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-arect">
<h3><a class="doc-anchor" href="#doc-arect">#</a> <code>arect</code></h3>
<p><code>arect</code> — geometry / physics builtin. Alias for <code>area_rectangle</code>.</p>
<pre><code class="lang-perl">my $result = arect $x
# or in a pipeline:
@list |> map arect |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-argc">
<h3><a class="doc-anchor" href="#doc-argc">#</a> <code>argc</code></h3>
<p><code>argc</code> — process / env builtin.</p>
<pre><code class="lang-perl">my $result = argc $x
# or in a pipeline:
@list |> map argc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-argmax">
<h3><a class="doc-anchor" href="#doc-argmax">#</a> <code>argmax</code></h3>
<p><code>argmax</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = argmax $x
# or in a pipeline:
@list |> map argmax |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-argmin">
<h3><a class="doc-anchor" href="#doc-argmin">#</a> <code>argmin</code></h3>
<p><code>argmin</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = argmin $x
# or in a pipeline:
@list |> map argmin |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-argsort">
<h3><a class="doc-anchor" href="#doc-argsort">#</a> <code>argsort</code></h3>
<p><code>argsort</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = argsort $x
# or in a pipeline:
@list |> map argsort |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-arithmetic-series">
<h3><a class="doc-anchor" href="#doc-arithmetic-series">#</a> <code>arithmetic_series</code></h3>
<p><code>arithmetic_series($a1, $d, $n)</code> (alias <code>arithser</code>) — sum of n terms of arithmetic sequence starting at a1 with common difference d. Formula: n/2 × (2a1 + (n-1)d).</p>
<pre><code class="lang-perl">p arithser(1, 1, 100) # 5050 (1+2+...+100)
p arithser(2, 3, 10) # 155 (2+5+8+...+29)
</code></pre>
</article>
<article class="doc-entry" id="doc-arity-of">
<h3><a class="doc-anchor" href="#doc-arity-of">#</a> <code>arity_of</code></h3>
<p><code>arity_of</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = arity_of $x
# or in a pipeline:
@list |> map arity_of |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-array-difference">
<h3><a class="doc-anchor" href="#doc-array-difference">#</a> <code>array_difference</code></h3>
<p><code>array_difference</code> — collection (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = array_difference $x
# or in a pipeline:
@list |> map array_difference |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-array-intersection">
<h3><a class="doc-anchor" href="#doc-array-intersection">#</a> <code>array_intersection</code></h3>
<p><code>array_intersection</code> — collection (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = array_intersection $x
# or in a pipeline:
@list |> map array_intersection |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-array-union">
<h3><a class="doc-anchor" href="#doc-array-union">#</a> <code>array_union</code></h3>
<p><code>array_union</code> — collection (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = array_union $x
# or in a pipeline:
@list |> map array_union |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ascii-chr">
<h3><a class="doc-anchor" href="#doc-ascii-chr">#</a> <code>ascii_chr</code></h3>
<p><code>ascii_chr</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = ascii_chr $x
# or in a pipeline:
@list |> map ascii_chr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ascii-ord">
<h3><a class="doc-anchor" href="#doc-ascii-ord">#</a> <code>ascii_ord</code></h3>
<p><code>ascii_ord</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = ascii_ord $x
# or in a pipeline:
@list |> map ascii_ord |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-asec">
<h3><a class="doc-anchor" href="#doc-asec">#</a> <code>asec</code></h3>
<p><code>asec</code> — trig extensions builtin.</p>
<pre><code class="lang-perl">my $result = asec $x
# or in a pipeline:
@list |> map asec |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-asin">
<h3><a class="doc-anchor" href="#doc-asin">#</a> <code>asin</code></h3>
<p><code>asin</code> — trig / math (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = asin $x
# or in a pipeline:
@list |> map asin |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-asinh">
<h3><a class="doc-anchor" href="#doc-asinh">#</a> <code>asinh</code></h3>
<p><code>asinh</code> — trig / math (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = asinh $x
# or in a pipeline:
@list |> map asinh |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-asrt">
<h3><a class="doc-anchor" href="#doc-asrt">#</a> <code>asrt</code></h3>
<p><code>asrt</code> — extended stdlib builtin. Alias for <code>argsort</code>.</p>
<pre><code class="lang-perl">my $result = asrt $x
# or in a pipeline:
@list |> map asrt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-assert-type">
<h3><a class="doc-anchor" href="#doc-assert-type">#</a> <code>assert_type</code></h3>
<p><code>assert_type</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = assert_type $x
# or in a pipeline:
@list |> map assert_type |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-assoc">
<h3><a class="doc-anchor" href="#doc-assoc">#</a> <code>assoc</code></h3>
<p><code>assoc</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = assoc $x
# or in a pipeline:
@list |> map assoc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-assoc-fn">
<h3><a class="doc-anchor" href="#doc-assoc-fn">#</a> <code>assoc_fn</code></h3>
<p><code>assoc_fn</code> — go/general functional utilities builtin. Alias for <code>associate</code>.</p>
<pre><code class="lang-perl">my $result = assoc_fn $x
# or in a pipeline:
@list |> map assoc_fn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-assoc-in">
<h3><a class="doc-anchor" href="#doc-assoc-in">#</a> <code>assoc_in</code></h3>
<p><code>assoc_in</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = assoc_in $x
# or in a pipeline:
@list |> map assoc_in |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-associate">
<h3><a class="doc-anchor" href="#doc-associate">#</a> <code>associate</code></h3>
<p><code>associate</code> — go/general functional utilities builtin.</p>
<pre><code class="lang-perl">my $result = associate $x
# or in a pipeline:
@list |> map associate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-astronomical-unit">
<h3><a class="doc-anchor" href="#doc-astronomical-unit">#</a> <code>astronomical_unit</code></h3>
<p><code>astronomical_unit</code> (alias <code>au</code>) — AU ≈ 1.496×10¹¹ m. Mean Earth-Sun distance.</p>
<pre><code class="lang-perl">p au # 1.495978707e11 m
p au / 1000 # ~149.6 million km
</code></pre>
</article>
<article class="doc-entry" id="doc-at-index">
<h3><a class="doc-anchor" href="#doc-at-index">#</a> <code>at_index</code></h3>
<p><code>at_index</code> — javascript array/object methods builtin.</p>
<pre><code class="lang-perl">my $result = at_index $x
# or in a pipeline:
@list |> map at_index |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-atan">
<h3><a class="doc-anchor" href="#doc-atan">#</a> <code>atan</code></h3>
<p><code>atan</code> — trig / math (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = atan $x
# or in a pipeline:
@list |> map atan |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-atanh">
<h3><a class="doc-anchor" href="#doc-atanh">#</a> <code>atanh</code></h3>
<p><code>atanh</code> — trig / math (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = atanh $x
# or in a pipeline:
@list |> map atanh |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-atbash">
<h3><a class="doc-anchor" href="#doc-atbash">#</a> <code>atbash</code></h3>
<p><code>atbash</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = atbash $x
# or in a pipeline:
@list |> map atbash |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-atc">
<h3><a class="doc-anchor" href="#doc-atc">#</a> <code>atc</code></h3>
<p><code>atc</code> — color operations builtin. Alias for <code>ansi_truecolor</code>.</p>
<pre><code class="lang-perl">my $result = atc $x
# or in a pipeline:
@list |> map atc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ati">
<h3><a class="doc-anchor" href="#doc-ati">#</a> <code>ati</code></h3>
<p><code>ati</code> — javascript array/object methods builtin. Alias for <code>at_index</code>.</p>
<pre><code class="lang-perl">my $result = ati $x
# or in a pipeline:
@list |> map ati |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-atime">
<h3><a class="doc-anchor" href="#doc-atime">#</a> <code>atime</code></h3>
<p><code>atime</code> — file stat / path builtin. Alias for <code>file_atime</code>.</p>
<pre><code class="lang-perl">my $result = atime $x
# or in a pipeline:
@list |> map atime |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-atomic-mass-unit">
<h3><a class="doc-anchor" href="#doc-atomic-mass-unit">#</a> <code>atomic_mass_unit</code></h3>
<p><code>atomic_mass_unit</code> — physics constants builtin.</p>
<pre><code class="lang-perl">my $result = atomic_mass_unit $x
# or in a pipeline:
@list |> map atomic_mass_unit |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-atrap">
<h3><a class="doc-anchor" href="#doc-atrap">#</a> <code>atrap</code></h3>
<p><code>atrap</code> — geometry / physics builtin. Alias for <code>area_trapezoid</code>.</p>
<pre><code class="lang-perl">my $result = atrap $x
# or in a pipeline:
@list |> map atrap |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-atri">
<h3><a class="doc-anchor" href="#doc-atri">#</a> <code>atri</code></h3>
<p><code>atri</code> — geometry / physics builtin. Alias for <code>area_triangle</code>.</p>
<pre><code class="lang-perl">my $result = atri $x
# or in a pipeline:
@list |> map atri |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-attempt">
<h3><a class="doc-anchor" href="#doc-attempt">#</a> <code>attempt</code></h3>
<p><code>attempt</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = attempt $x
# or in a pipeline:
@list |> map attempt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-autocorrelation">
<h3><a class="doc-anchor" href="#doc-autocorrelation">#</a> <code>autocorrelation</code></h3>
<p><code>autocorrelation</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = autocorrelation $x
# or in a pipeline:
@list |> map autocorrelation |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-average">
<h3><a class="doc-anchor" href="#doc-average">#</a> <code>average</code></h3>
<p><code>average</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = average $x
# or in a pipeline:
@list |> map average |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-avg">
<h3><a class="doc-anchor" href="#doc-avg">#</a> <code>avg</code></h3>
<p><code>avg</code> — pipeline / string helpers builtin.</p>
<pre><code class="lang-perl">my $result = avg $x
# or in a pipeline:
@list |> map avg |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-avogadro">
<h3><a class="doc-anchor" href="#doc-avogadro">#</a> <code>avogadro</code></h3>
<p><code>avogadro</code> — math / physics constants builtin.</p>
<pre><code class="lang-perl">my $result = avogadro $x
# or in a pipeline:
@list |> map avogadro |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-avogadro-number">
<h3><a class="doc-anchor" href="#doc-avogadro-number">#</a> <code>avogadro_number</code></h3>
<p><code>avogadro_number</code> — constants builtin.</p>
<pre><code class="lang-perl">my $result = avogadro_number $x
# or in a pipeline:
@list |> map avogadro_number |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-b2gray">
<h3><a class="doc-anchor" href="#doc-b2gray">#</a> <code>b2gray</code></h3>
<p><code>b2gray</code> — base / gray code builtin. Alias for <code>binary_to_gray</code>.</p>
<pre><code class="lang-perl">my $result = b2gray $x
# or in a pipeline:
@list |> map b2gray |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-b2i">
<h3><a class="doc-anchor" href="#doc-b2i">#</a> <code>b2i</code></h3>
<p><code>b2i</code> — boolean combinators builtin. Alias for <code>bool_to_int</code>.</p>
<pre><code class="lang-perl">my $result = b2i $x
# or in a pipeline:
@list |> map b2i |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-b64d">
<h3><a class="doc-anchor" href="#doc-b64d">#</a> <code>b64d</code></h3>
<p><code>b64d</code> — crypto / encoding builtin. Alias for <code>base64_decode</code>.</p>
<pre><code class="lang-perl">my $result = b64d $x
# or in a pipeline:
@list |> map b64d |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-b64e">
<h3><a class="doc-anchor" href="#doc-b64e">#</a> <code>b64e</code></h3>
<p><code>b64e</code> — crypto / encoding builtin. Alias for <code>base64_encode</code>.</p>
<pre><code class="lang-perl">my $result = b64e $x
# or in a pipeline:
@list |> map b64e |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-b-to-kb">
<h3><a class="doc-anchor" href="#doc-b-to-kb">#</a> <code>b_to_kb</code></h3>
<p><code>b_to_kb</code> — unit conversions builtin. Alias for <code>bytes_to_kb</code>.</p>
<pre><code class="lang-perl">my $result = b_to_kb $input
</code></pre>
</article>
<article class="doc-entry" id="doc-b-wien">
<h3><a class="doc-anchor" href="#doc-b-wien">#</a> <code>b_wien</code></h3>
<p><code>b_wien</code> — physics constants builtin. Alias for <code>wien_constant</code>.</p>
<pre><code class="lang-perl">my $result = b_wien $x
# or in a pipeline:
@list |> map b_wien |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bac">
<h3><a class="doc-anchor" href="#doc-bac">#</a> <code>bac</code></h3>
<p><code>bac</code> — finance builtin. Alias for <code>bac_estimate</code>.</p>
<pre><code class="lang-perl">my $result = bac $x
# or in a pipeline:
@list |> map bac |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bac-estimate">
<h3><a class="doc-anchor" href="#doc-bac-estimate">#</a> <code>bac_estimate</code></h3>
<p><code>bac_estimate</code> — finance builtin.</p>
<pre><code class="lang-perl">my $result = bac_estimate $x
# or in a pipeline:
@list |> map bac_estimate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bandpass-filter">
<h3><a class="doc-anchor" href="#doc-bandpass-filter">#</a> <code>bandpass_filter</code></h3>
<p><code>bandpass_filter(\@signal, $low, $high)</code> (alias <code>bpf</code>) — applies a band-pass filter passing frequencies between low and high cutoffs. Combines low-pass and high-pass.</p>
<pre><code class="lang-perl">my $filtered = bpf(\@signal, 0.1, 0.3)
</code></pre>
</article>
<article class="doc-entry" id="doc-bar-to-pascals">
<h3><a class="doc-anchor" href="#doc-bar-to-pascals">#</a> <code>bar_to_pascals</code></h3>
<p><code>bar_to_pascals</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = bar_to_pascals $input
</code></pre>
</article>
<article class="doc-entry" id="doc-base-convert">
<h3><a class="doc-anchor" href="#doc-base-convert">#</a> <code>base_convert</code></h3>
<p><code>base_convert</code> — base / gray code builtin.</p>
<pre><code class="lang-perl">my $result = base_convert $x
# or in a pipeline:
@list |> map base_convert |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-batch">
<h3><a class="doc-anchor" href="#doc-batch">#</a> <code>batch</code></h3>
<p><code>batch</code> — collection (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = batch $x
# or in a pipeline:
@list |> map batch |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-batched">
<h3><a class="doc-anchor" href="#doc-batched">#</a> <code>batched</code></h3>
<p><code>batched</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = batched $x
# or in a pipeline:
@list |> map batched |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bbox">
<h3><a class="doc-anchor" href="#doc-bbox">#</a> <code>bbox</code></h3>
<p><code>bounding_box(@points)</code> (alias <code>bbox</code>) — computes the axis-aligned bounding box of 2D points. Returns [min_x, min_y, max_x, max_y].</p>
<pre><code class="lang-perl">my @pts = (1,2, 3,4, 0,1, 5,3)
my $bb = bbox(@pts)
p @$bb # (0, 1, 5, 4)
</code></pre>
</article>
<article class="doc-entry" id="doc-bconv">
<h3><a class="doc-anchor" href="#doc-bconv">#</a> <code>bconv</code></h3>
<p><code>bconv</code> — base / gray code builtin. Alias for <code>base_convert</code>.</p>
<pre><code class="lang-perl">my $result = bconv $x
# or in a pipeline:
@list |> map bconv |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bcount">
<h3><a class="doc-anchor" href="#doc-bcount">#</a> <code>bcount</code></h3>
<p><code>bcount</code> — extended stdlib batch 3 builtin. Alias for <code>count_bytes</code>.</p>
<pre><code class="lang-perl">my $result = bcount $x
# or in a pipeline:
@list |> map bcount |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bearing">
<h3><a class="doc-anchor" href="#doc-bearing">#</a> <code>bearing</code></h3>
<p><code>bearing</code> — geometry / physics builtin.</p>
<pre><code class="lang-perl">my $result = bearing $x
# or in a pipeline:
@list |> map bearing |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-before-n">
<h3><a class="doc-anchor" href="#doc-before-n">#</a> <code>before_n</code></h3>
<p><code>before_n</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = before_n $x
# or in a pipeline:
@list |> map before_n |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bell-number">
<h3><a class="doc-anchor" href="#doc-bell-number">#</a> <code>bell_number</code></h3>
<p><code>bell_number</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = bell_number $x
# or in a pipeline:
@list |> map bell_number |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bellman-ford">
<h3><a class="doc-anchor" href="#doc-bellman-ford">#</a> <code>bellman_ford</code></h3>
<p><code>bellman_ford</code> (alias <code>bellmanford</code>) computes shortest paths from a source in a graph with negative weights. Takes edges [[u,v,w],...], node count, source index.</p>
<pre><code class="lang-perl">my $d = bellmanford([[0,1,4],[0,2,5],[1,2,-3]], 3, 0)
</code></pre>
</article>
<article class="doc-entry" id="doc-belln">
<h3><a class="doc-anchor" href="#doc-belln">#</a> <code>belln</code></h3>
<p><code>belln</code> — math / numeric (uncategorized batch) builtin. Alias for <code>bell_number</code>.</p>
<pre><code class="lang-perl">my $result = belln $x
# or in a pipeline:
@list |> map belln |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bernoulli">
<h3><a class="doc-anchor" href="#doc-bernoulli">#</a> <code>bernoulli</code></h3>
<p><code>bernoulli_number</code> (alias <code>bernoulli</code>) computes the nth Bernoulli number. B(0)=1, B(1)=-0.5, odd B(n>1)=0.</p>
<pre><code class="lang-perl">p bernoulli(0) # 1
p bernoulli(2) # 0.1667
p bernoulli(4) # -0.0333
</code></pre>
</article>
<article class="doc-entry" id="doc-bessel-j0">
<h3><a class="doc-anchor" href="#doc-bessel-j0">#</a> <code>bessel_j0</code></h3>
<p><code>bessel_j0</code> (alias <code>j0</code>) computes the Bessel function of the first kind, order 0.</p>
<pre><code class="lang-perl">p j0(0) # 1.0
p j0(2.4) # ≈ 0 (first zero)
</code></pre>
</article>
<article class="doc-entry" id="doc-bessel-j1">
<h3><a class="doc-anchor" href="#doc-bessel-j1">#</a> <code>bessel_j1</code></h3>
<p><code>bessel_j1</code> (alias <code>j1</code>) computes the Bessel function of the first kind, order 1.</p>
<pre><code class="lang-perl">p j1(0) # 0.0
p j1(1.84) # ≈ 0.582 (first max)
</code></pre>
</article>
<article class="doc-entry" id="doc-beta-pdf">
<h3><a class="doc-anchor" href="#doc-beta-pdf">#</a> <code>beta_pdf</code></h3>
<p><code>beta_pdf</code> (alias <code>betapdf</code>) evaluates the Beta distribution PDF at x with shape parameters alpha and beta.</p>
<pre><code class="lang-perl">p betapdf(0.5, 2, 5) # Beta(2,5) at x=0.5
</code></pre>
</article>
<article class="doc-entry" id="doc-between">
<h3><a class="doc-anchor" href="#doc-between">#</a> <code>between</code></h3>
<p><code>between</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = between $x
# or in a pipeline:
@list |> map between |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bfs">
<h3><a class="doc-anchor" href="#doc-bfs">#</a> <code>bfs</code></h3>
<p><code>bfs</code> — extended stdlib builtin. Alias for <code>bfs_traverse</code>.</p>
<pre><code class="lang-perl">my $result = bfs $x
# or in a pipeline:
@list |> map bfs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bfs-traverse">
<h3><a class="doc-anchor" href="#doc-bfs-traverse">#</a> <code>bfs_traverse</code></h3>
<p><code>bfs_traverse</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = bfs_traverse $x
# or in a pipeline:
@list |> map bfs_traverse |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bg-black">
<h3><a class="doc-anchor" href="#doc-bg-black">#</a> <code>bg_black</code></h3>
<p><code>bg_black</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bg_black $x
# or in a pipeline:
@list |> map bg_black |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bg-blue">
<h3><a class="doc-anchor" href="#doc-bg-blue">#</a> <code>bg_blue</code></h3>
<p><code>bg_blue</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bg_blue $x
# or in a pipeline:
@list |> map bg_blue |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bg-bright-blue">
<h3><a class="doc-anchor" href="#doc-bg-bright-blue">#</a> <code>bg_bright_blue</code></h3>
<p><code>bg_bright_blue</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bg_bright_blue $x
# or in a pipeline:
@list |> map bg_bright_blue |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bg-bright-cyan">
<h3><a class="doc-anchor" href="#doc-bg-bright-cyan">#</a> <code>bg_bright_cyan</code></h3>
<p><code>bg_bright_cyan</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bg_bright_cyan $x
# or in a pipeline:
@list |> map bg_bright_cyan |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bg-bright-green">
<h3><a class="doc-anchor" href="#doc-bg-bright-green">#</a> <code>bg_bright_green</code></h3>
<p><code>bg_bright_green</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bg_bright_green $x
# or in a pipeline:
@list |> map bg_bright_green |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bg-bright-magenta">
<h3><a class="doc-anchor" href="#doc-bg-bright-magenta">#</a> <code>bg_bright_magenta</code></h3>
<p><code>bg_bright_magenta</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bg_bright_magenta $x
# or in a pipeline:
@list |> map bg_bright_magenta |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bg-bright-red">
<h3><a class="doc-anchor" href="#doc-bg-bright-red">#</a> <code>bg_bright_red</code></h3>
<p><code>bg_bright_red</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bg_bright_red $x
# or in a pipeline:
@list |> map bg_bright_red |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bg-bright-white">
<h3><a class="doc-anchor" href="#doc-bg-bright-white">#</a> <code>bg_bright_white</code></h3>
<p><code>bg_bright_white</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bg_bright_white $x
# or in a pipeline:
@list |> map bg_bright_white |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bg-bright-yellow">
<h3><a class="doc-anchor" href="#doc-bg-bright-yellow">#</a> <code>bg_bright_yellow</code></h3>
<p><code>bg_bright_yellow</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bg_bright_yellow $x
# or in a pipeline:
@list |> map bg_bright_yellow |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bg-c256">
<h3><a class="doc-anchor" href="#doc-bg-c256">#</a> <code>bg_c256</code></h3>
<p><code>bg_c256</code> — color / ansi builtin. Alias for <code>bg_color256</code>.</p>
<pre><code class="lang-perl">my $result = bg_c256 $x
# or in a pipeline:
@list |> map bg_c256 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bg-color256">
<h3><a class="doc-anchor" href="#doc-bg-color256">#</a> <code>bg_color256</code></h3>
<p><code>bg_color256</code> — color / ansi builtin.</p>
<pre><code class="lang-perl">my $result = bg_color256 $x
# or in a pipeline:
@list |> map bg_color256 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bg-cyan">
<h3><a class="doc-anchor" href="#doc-bg-cyan">#</a> <code>bg_cyan</code></h3>
<p><code>bg_cyan</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bg_cyan $x
# or in a pipeline:
@list |> map bg_cyan |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bg-green">
<h3><a class="doc-anchor" href="#doc-bg-green">#</a> <code>bg_green</code></h3>
<p><code>bg_green</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bg_green $x
# or in a pipeline:
@list |> map bg_green |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bg-magenta">
<h3><a class="doc-anchor" href="#doc-bg-magenta">#</a> <code>bg_magenta</code></h3>
<p><code>bg_magenta</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bg_magenta $x
# or in a pipeline:
@list |> map bg_magenta |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bg-red">
<h3><a class="doc-anchor" href="#doc-bg-red">#</a> <code>bg_red</code></h3>
<p><code>bg_red</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bg_red $x
# or in a pipeline:
@list |> map bg_red |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bg-rgb">
<h3><a class="doc-anchor" href="#doc-bg-rgb">#</a> <code>bg_rgb</code></h3>
<p><code>bg_rgb</code> — color / ansi builtin.</p>
<pre><code class="lang-perl">my $result = bg_rgb $x
# or in a pipeline:
@list |> map bg_rgb |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bg-white">
<h3><a class="doc-anchor" href="#doc-bg-white">#</a> <code>bg_white</code></h3>
<p><code>bg_white</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bg_white $x
# or in a pipeline:
@list |> map bg_white |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bg-yellow">
<h3><a class="doc-anchor" href="#doc-bg-yellow">#</a> <code>bg_yellow</code></h3>
<p><code>bg_yellow</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bg_yellow $x
# or in a pipeline:
@list |> map bg_yellow |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bigram">
<h3><a class="doc-anchor" href="#doc-bigram">#</a> <code>bigram</code></h3>
<p><code>bigram</code> — string processing (uncategorized batch) builtin. Alias for <code>bigrams</code>.</p>
<pre><code class="lang-perl">my $result = bigram $x
# or in a pipeline:
@list |> map bigram |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bigrams">
<h3><a class="doc-anchor" href="#doc-bigrams">#</a> <code>bigrams</code></h3>
<p><code>bigrams</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = bigrams $x
# or in a pipeline:
@list |> map bigrams |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bin-of">
<h3><a class="doc-anchor" href="#doc-bin-of">#</a> <code>bin_of</code></h3>
<p><code>bin_of</code> — base conversion builtin. Alias for <code>to_bin</code>.</p>
<pre><code class="lang-perl">my $result = bin_of $x
# or in a pipeline:
@list |> map bin_of |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-binary-insert">
<h3><a class="doc-anchor" href="#doc-binary-insert">#</a> <code>binary_insert</code></h3>
<p><code>binary_insert</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = binary_insert $x
# or in a pipeline:
@list |> map binary_insert |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-binary-search">
<h3><a class="doc-anchor" href="#doc-binary-search">#</a> <code>binary_search</code></h3>
<p><code>binary_search</code> — collection (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = binary_search $x
# or in a pipeline:
@list |> map binary_search |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-binary-to-gray">
<h3><a class="doc-anchor" href="#doc-binary-to-gray">#</a> <code>binary_to_gray</code></h3>
<p><code>binary_to_gray</code> — base / gray code builtin.</p>
<pre><code class="lang-perl">my $result = binary_to_gray $input
</code></pre>
</article>
<article class="doc-entry" id="doc-binom">
<h3><a class="doc-anchor" href="#doc-binom">#</a> <code>binom</code></h3>
<p><code>binom</code> — extended stdlib batch 3 builtin. Alias for <code>binomial</code>.</p>
<pre><code class="lang-perl">my $result = binom $x
# or in a pipeline:
@list |> map binom |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-binom-test">
<h3><a class="doc-anchor" href="#doc-binom-test">#</a> <code>binom_test</code></h3>
<p><code>binom_test</code> — exact binomial test. Returns two-sided p-value. Like R's binom.test().</p>
<pre><code class="lang-perl">my $p = binomtest(7, 10, 0.5) # p-value for 7/10 successes vs p=0.5
</code></pre>
</article>
<article class="doc-entry" id="doc-binomial">
<h3><a class="doc-anchor" href="#doc-binomial">#</a> <code>binomial</code></h3>
<p><code>binomial</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = binomial $x
# or in a pipeline:
@list |> map binomial |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-binsert">
<h3><a class="doc-anchor" href="#doc-binsert">#</a> <code>binsert</code></h3>
<p><code>binsert</code> — matrix operations (uncategorized batch) builtin. Alias for <code>binary_insert</code>.</p>
<pre><code class="lang-perl">my $result = binsert $x
# or in a pipeline:
@list |> map binsert |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bisect">
<h3><a class="doc-anchor" href="#doc-bisect">#</a> <code>bisect</code></h3>
<p><code>bisection</code> (alias <code>bisect</code>) finds a root of f(x)=0 in [a,b] via the bisection method. Takes a code ref, a, b, and optional tolerance.</p>
<pre><code class="lang-perl">my $root = bisect(fn { $_[0]**2 - 2 }, 1, 2) # √2 ≈ 1.4142
</code></pre>
</article>
<article class="doc-entry" id="doc-bit-and">
<h3><a class="doc-anchor" href="#doc-bit-and">#</a> <code>bit_and</code></h3>
<p><code>bit_and</code> — bit ops builtin.</p>
<pre><code class="lang-perl">my $result = bit_and $x
# or in a pipeline:
@list |> map bit_and |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bit-clear">
<h3><a class="doc-anchor" href="#doc-bit-clear">#</a> <code>bit_clear</code></h3>
<p><code>bit_clear</code> — bit ops builtin.</p>
<pre><code class="lang-perl">my $result = bit_clear $x
# or in a pipeline:
@list |> map bit_clear |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bit-length">
<h3><a class="doc-anchor" href="#doc-bit-length">#</a> <code>bit_length</code></h3>
<p><code>bit_length</code> — base conversion builtin.</p>
<pre><code class="lang-perl">my $result = bit_length $x
# or in a pipeline:
@list |> map bit_length |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bit-not">
<h3><a class="doc-anchor" href="#doc-bit-not">#</a> <code>bit_not</code></h3>
<p><code>bit_not</code> — bit ops builtin.</p>
<pre><code class="lang-perl">my $result = bit_not $x
# or in a pipeline:
@list |> map bit_not |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bit-or">
<h3><a class="doc-anchor" href="#doc-bit-or">#</a> <code>bit_or</code></h3>
<p><code>bit_or</code> — bit ops builtin.</p>
<pre><code class="lang-perl">my $result = bit_or $x
# or in a pipeline:
@list |> map bit_or |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bit-set">
<h3><a class="doc-anchor" href="#doc-bit-set">#</a> <code>bit_set</code></h3>
<p><code>bit_set</code> — bit ops builtin.</p>
<pre><code class="lang-perl">my $result = bit_set $x
# or in a pipeline:
@list |> map bit_set |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bit-test">
<h3><a class="doc-anchor" href="#doc-bit-test">#</a> <code>bit_test</code></h3>
<p><code>bit_test</code> — bit ops builtin.</p>
<pre><code class="lang-perl">my $result = bit_test $x
# or in a pipeline:
@list |> map bit_test |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bit-toggle">
<h3><a class="doc-anchor" href="#doc-bit-toggle">#</a> <code>bit_toggle</code></h3>
<p><code>bit_toggle</code> — bit ops builtin.</p>
<pre><code class="lang-perl">my $result = bit_toggle $x
# or in a pipeline:
@list |> map bit_toggle |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bit-xor">
<h3><a class="doc-anchor" href="#doc-bit-xor">#</a> <code>bit_xor</code></h3>
<p><code>bit_xor</code> — bit ops builtin.</p>
<pre><code class="lang-perl">my $result = bit_xor $x
# or in a pipeline:
@list |> map bit_xor |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bitlen">
<h3><a class="doc-anchor" href="#doc-bitlen">#</a> <code>bitlen</code></h3>
<p><code>bitlen</code> — base conversion builtin. Alias for <code>bit_length</code>.</p>
<pre><code class="lang-perl">my $result = bitlen $x
# or in a pipeline:
@list |> map bitlen |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bits-count">
<h3><a class="doc-anchor" href="#doc-bits-count">#</a> <code>bits_count</code></h3>
<p><code>bits_count</code> — base conversion builtin.</p>
<pre><code class="lang-perl">my $result = bits_count $x
# or in a pipeline:
@list |> map bits_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bits-to-bytes">
<h3><a class="doc-anchor" href="#doc-bits-to-bytes">#</a> <code>bits_to_bytes</code></h3>
<p><code>bits_to_bytes</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = bits_to_bytes $input
</code></pre>
</article>
<article class="doc-entry" id="doc-bitset-clear">
<h3><a class="doc-anchor" href="#doc-bitset-clear">#</a> <code>bitset_clear</code></h3>
<p><code>bitset_clear</code> — data structure helpers builtin.</p>
<pre><code class="lang-perl">my $result = bitset_clear $x
# or in a pipeline:
@list |> map bitset_clear |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bitset-new">
<h3><a class="doc-anchor" href="#doc-bitset-new">#</a> <code>bitset_new</code></h3>
<p><code>bitset_new</code> — data structure helpers builtin.</p>
<pre><code class="lang-perl">my $result = bitset_new $x
# or in a pipeline:
@list |> map bitset_new |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bitset-set">
<h3><a class="doc-anchor" href="#doc-bitset-set">#</a> <code>bitset_set</code></h3>
<p><code>bitset_set</code> — data structure helpers builtin.</p>
<pre><code class="lang-perl">my $result = bitset_set $x
# or in a pipeline:
@list |> map bitset_set |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bitset-test">
<h3><a class="doc-anchor" href="#doc-bitset-test">#</a> <code>bitset_test</code></h3>
<p><code>bitset_test</code> — data structure helpers builtin.</p>
<pre><code class="lang-perl">my $result = bitset_test $x
# or in a pipeline:
@list |> map bitset_test |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bkt">
<h3><a class="doc-anchor" href="#doc-bkt">#</a> <code>bkt</code></h3>
<p><code>bkt</code> — matrix operations (uncategorized batch) builtin. Alias for <code>bucket</code>.</p>
<pre><code class="lang-perl">my $result = bkt $x
# or in a pipeline:
@list |> map bkt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bl">
<h3><a class="doc-anchor" href="#doc-bl">#</a> <code>bl</code></h3>
<p><code>bl</code> — algebraic match builtin. Alias for <code>butlast</code>.</p>
<pre><code class="lang-perl">my $result = bl $x
# or in a pipeline:
@list |> map bl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-black">
<h3><a class="doc-anchor" href="#doc-black">#</a> <code>black</code></h3>
<p><code>black</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = black $x
# or in a pipeline:
@list |> map black |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-black-scholes-call">
<h3><a class="doc-anchor" href="#doc-black-scholes-call">#</a> <code>black_scholes_call</code></h3>
<p><code>black_scholes_call($S, $K, $r, $T, $sigma)</code> (alias <code>bscall</code>) — computes Black-Scholes price for a European call option. S=spot, K=strike, r=rate, T=time to expiry, sigma=volatility.</p>
<pre><code class="lang-perl">p bscall(100, 100, 0.05, 1, 0.2) # ~10.45
</code></pre>
</article>
<article class="doc-entry" id="doc-black-scholes-put">
<h3><a class="doc-anchor" href="#doc-black-scholes-put">#</a> <code>black_scholes_put</code></h3>
<p><code>black_scholes_put($S, $K, $r, $T, $sigma)</code> (alias <code>bsput</code>) — computes Black-Scholes price for a European put option.</p>
<pre><code class="lang-perl">p bsput(100, 100, 0.05, 1, 0.2) # ~5.57
</code></pre>
</article>
<article class="doc-entry" id="doc-blackman">
<h3><a class="doc-anchor" href="#doc-blackman">#</a> <code>blackman</code></h3>
<p><code>window_blackman($n)</code> (alias <code>blackman</code>) — generates a Blackman window of length n. Provides excellent sidelobe suppression at the cost of main lobe width.</p>
<pre><code class="lang-perl">my $w = blackman(1024)
</code></pre>
</article>
<article class="doc-entry" id="doc-blink">
<h3><a class="doc-anchor" href="#doc-blink">#</a> <code>blink</code></h3>
<p><code>blink</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = blink $x
# or in a pipeline:
@list |> map blink |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-block-devices">
<h3><a class="doc-anchor" href="#doc-block-devices">#</a> <code>block_devices</code></h3>
<p><code>block_devices</code> — filesystem extensions builtin.</p>
<pre><code class="lang-perl">my $result = block_devices $x
# or in a pipeline:
@list |> map block_devices |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-blue">
<h3><a class="doc-anchor" href="#doc-blue">#</a> <code>blue</code></h3>
<p><code>blue</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = blue $x
# or in a pipeline:
@list |> map blue |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-blue-bold">
<h3><a class="doc-anchor" href="#doc-blue-bold">#</a> <code>blue_bold</code></h3>
<p><code>blue_bold</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = blue_bold $x
# or in a pipeline:
@list |> map blue_bold |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bmi">
<h3><a class="doc-anchor" href="#doc-bmi">#</a> <code>bmi</code></h3>
<p><code>bmi</code> — finance builtin.</p>
<pre><code class="lang-perl">my $result = bmi $x
# or in a pipeline:
@list |> map bmi |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bmi-calc">
<h3><a class="doc-anchor" href="#doc-bmi-calc">#</a> <code>bmi_calc</code></h3>
<p><code>bmi_calc</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = bmi_calc $x
# or in a pipeline:
@list |> map bmi_calc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bohr-magneton">
<h3><a class="doc-anchor" href="#doc-bohr-magneton">#</a> <code>bohr_magneton</code></h3>
<p><code>bohr_magneton</code> — physics constants builtin.</p>
<pre><code class="lang-perl">my $result = bohr_magneton $x
# or in a pipeline:
@list |> map bohr_magneton |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bold">
<h3><a class="doc-anchor" href="#doc-bold">#</a> <code>bold</code></h3>
<p><code>bold</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bold $x
# or in a pipeline:
@list |> map bold |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bold-blue">
<h3><a class="doc-anchor" href="#doc-bold-blue">#</a> <code>bold_blue</code></h3>
<p><code>bold_blue</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bold_blue $x
# or in a pipeline:
@list |> map bold_blue |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bold-cyan">
<h3><a class="doc-anchor" href="#doc-bold-cyan">#</a> <code>bold_cyan</code></h3>
<p><code>bold_cyan</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bold_cyan $x
# or in a pipeline:
@list |> map bold_cyan |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bold-green">
<h3><a class="doc-anchor" href="#doc-bold-green">#</a> <code>bold_green</code></h3>
<p><code>bold_green</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bold_green $x
# or in a pipeline:
@list |> map bold_green |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bold-magenta">
<h3><a class="doc-anchor" href="#doc-bold-magenta">#</a> <code>bold_magenta</code></h3>
<p><code>bold_magenta</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bold_magenta $x
# or in a pipeline:
@list |> map bold_magenta |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bold-red">
<h3><a class="doc-anchor" href="#doc-bold-red">#</a> <code>bold_red</code></h3>
<p><code>bold_red</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bold_red $x
# or in a pipeline:
@list |> map bold_red |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bold-white">
<h3><a class="doc-anchor" href="#doc-bold-white">#</a> <code>bold_white</code></h3>
<p><code>bold_white</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bold_white $x
# or in a pipeline:
@list |> map bold_white |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bold-yellow">
<h3><a class="doc-anchor" href="#doc-bold-yellow">#</a> <code>bold_yellow</code></h3>
<p><code>bold_yellow</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bold_yellow $x
# or in a pipeline:
@list |> map bold_yellow |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-boltz">
<h3><a class="doc-anchor" href="#doc-boltz">#</a> <code>boltz</code></h3>
<p><code>boltz</code> — constants builtin. Alias for <code>boltzmann_constant</code>.</p>
<pre><code class="lang-perl">my $result = boltz $x
# or in a pipeline:
@list |> map boltz |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-boltzmann">
<h3><a class="doc-anchor" href="#doc-boltzmann">#</a> <code>boltzmann</code></h3>
<p><code>boltzmann</code> — math / physics constants builtin.</p>
<pre><code class="lang-perl">my $result = boltzmann $x
# or in a pipeline:
@list |> map boltzmann |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-boltzmann-constant">
<h3><a class="doc-anchor" href="#doc-boltzmann-constant">#</a> <code>boltzmann_constant</code></h3>
<p><code>boltzmann_constant</code> — constants builtin.</p>
<pre><code class="lang-perl">my $result = boltzmann_constant $x
# or in a pipeline:
@list |> map boltzmann_constant |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bond-duration">
<h3><a class="doc-anchor" href="#doc-bond-duration">#</a> <code>bond_duration</code></h3>
<p><code>duration($face, $coupon_rate, $ytm, $periods)</code> (alias <code>bond_duration</code>) — computes the Macaulay duration of a bond, measuring interest rate sensitivity as weighted average time to receive cash flows.</p>
<pre><code class="lang-perl">p duration(1000, 0.05, 0.05, 10) # ~7.7 years
</code></pre>
</article>
<article class="doc-entry" id="doc-bond-price">
<h3><a class="doc-anchor" href="#doc-bond-price">#</a> <code>bond_price</code></h3>
<p><code>bond_price($face, $coupon_rate, $ytm, $periods)</code> — computes the present value (price) of a bond given face value, coupon rate, yield to maturity, and number of periods.</p>
<pre><code class="lang-perl">p bond_price(1000, 0.05, 0.04, 10) # ~1081 (premium)
p bond_price(1000, 0.05, 0.06, 10) # ~926 (discount)
</code></pre>
</article>
<article class="doc-entry" id="doc-bond-yield">
<h3><a class="doc-anchor" href="#doc-bond-yield">#</a> <code>bond_yield</code></h3>
<p><code>bond_yield($price, $face, $coupon_rate, $periods)</code> — computes the yield to maturity of a bond given its current price. Uses Newton-Raphson iteration.</p>
<pre><code class="lang-perl">p bond_yield(950, 1000, 0.05, 10) # ~5.7%
</code></pre>
</article>
<article class="doc-entry" id="doc-bondprc">
<h3><a class="doc-anchor" href="#doc-bondprc">#</a> <code>bondprc</code></h3>
<p><code>bondprc</code> — finance (extended) builtin. Alias for <code>bond_price</code>.</p>
<pre><code class="lang-perl">my $result = bondprc $x
# or in a pipeline:
@list |> map bondprc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bondyld">
<h3><a class="doc-anchor" href="#doc-bondyld">#</a> <code>bondyld</code></h3>
<p><code>bondyld</code> — finance (extended) builtin. Alias for <code>bond_yield</code>.</p>
<pre><code class="lang-perl">my $result = bondyld $x
# or in a pipeline:
@list |> map bondyld |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bool-each">
<h3><a class="doc-anchor" href="#doc-bool-each">#</a> <code>bool_each</code></h3>
<p><code>bool_each</code> — trivial numeric helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = bool_each $x
# or in a pipeline:
@list |> map bool_each |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bool-to-int">
<h3><a class="doc-anchor" href="#doc-bool-to-int">#</a> <code>bool_to_int</code></h3>
<p><code>bool_to_int</code> — boolean combinators builtin.</p>
<pre><code class="lang-perl">my $result = bool_to_int $input
</code></pre>
</article>
<article class="doc-entry" id="doc-both">
<h3><a class="doc-anchor" href="#doc-both">#</a> <code>both</code></h3>
<p><code>both</code> — boolean combinators builtin.</p>
<pre><code class="lang-perl">my $result = both $x
# or in a pipeline:
@list |> map both |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bracket">
<h3><a class="doc-anchor" href="#doc-bracket">#</a> <code>bracket</code></h3>
<p><code>bracket</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = bracket $x
# or in a pipeline:
@list |> map bracket |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-braille">
<h3><a class="doc-anchor" href="#doc-braille">#</a> <code>braille</code></h3>
<p><code>braille</code> — encoding / phonetics builtin. Alias for <code>braille_encode</code>.</p>
<pre><code class="lang-perl">my $result = braille $x
# or in a pipeline:
@list |> map braille |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-braille-encode">
<h3><a class="doc-anchor" href="#doc-braille-encode">#</a> <code>braille_encode</code></h3>
<p><code>braille_encode</code> — encoding / phonetics builtin.</p>
<pre><code class="lang-perl">my $result = braille_encode $x
# or in a pipeline:
@list |> map braille_encode |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-break-even">
<h3><a class="doc-anchor" href="#doc-break-even">#</a> <code>break_even</code></h3>
<p><code>break_even</code> — finance builtin.</p>
<pre><code class="lang-perl">my $result = break_even $x
# or in a pipeline:
@list |> map break_even |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-break-fn">
<h3><a class="doc-anchor" href="#doc-break-fn">#</a> <code>break_fn</code></h3>
<p><code>break_fn</code> — haskell list functions builtin.</p>
<pre><code class="lang-perl">my $result = break_fn $x
# or in a pipeline:
@list |> map break_fn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-breakeven">
<h3><a class="doc-anchor" href="#doc-breakeven">#</a> <code>breakeven</code></h3>
<p><code>breakeven</code> — finance builtin. Alias for <code>break_even</code>.</p>
<pre><code class="lang-perl">my $result = breakeven $x
# or in a pipeline:
@list |> map breakeven |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-brewster">
<h3><a class="doc-anchor" href="#doc-brewster">#</a> <code>brewster</code></h3>
<p><code>brewster</code> — physics formulas builtin. Alias for <code>brewster_angle</code>.</p>
<pre><code class="lang-perl">my $result = brewster $x
# or in a pipeline:
@list |> map brewster |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-brewster-angle">
<h3><a class="doc-anchor" href="#doc-brewster-angle">#</a> <code>brewster_angle</code></h3>
<p><code>brewster_angle</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = brewster_angle $x
# or in a pipeline:
@list |> map brewster_angle |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bright-blue">
<h3><a class="doc-anchor" href="#doc-bright-blue">#</a> <code>bright_blue</code></h3>
<p><code>bright_blue</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bright_blue $x
# or in a pipeline:
@list |> map bright_blue |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bright-cyan">
<h3><a class="doc-anchor" href="#doc-bright-cyan">#</a> <code>bright_cyan</code></h3>
<p><code>bright_cyan</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bright_cyan $x
# or in a pipeline:
@list |> map bright_cyan |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bright-green">
<h3><a class="doc-anchor" href="#doc-bright-green">#</a> <code>bright_green</code></h3>
<p><code>bright_green</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bright_green $x
# or in a pipeline:
@list |> map bright_green |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bright-magenta">
<h3><a class="doc-anchor" href="#doc-bright-magenta">#</a> <code>bright_magenta</code></h3>
<p><code>bright_magenta</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bright_magenta $x
# or in a pipeline:
@list |> map bright_magenta |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bright-red">
<h3><a class="doc-anchor" href="#doc-bright-red">#</a> <code>bright_red</code></h3>
<p><code>bright_red</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bright_red $x
# or in a pipeline:
@list |> map bright_red |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bright-white">
<h3><a class="doc-anchor" href="#doc-bright-white">#</a> <code>bright_white</code></h3>
<p><code>bright_white</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bright_white $x
# or in a pipeline:
@list |> map bright_white |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bright-yellow">
<h3><a class="doc-anchor" href="#doc-bright-yellow">#</a> <code>bright_yellow</code></h3>
<p><code>bright_yellow</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = bright_yellow $x
# or in a pipeline:
@list |> map bright_yellow |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-brkf">
<h3><a class="doc-anchor" href="#doc-brkf">#</a> <code>brkf</code></h3>
<p><code>brkf</code> — haskell list functions builtin. Alias for <code>break_fn</code>.</p>
<pre><code class="lang-perl">my $result = brkf $x
# or in a pipeline:
@list |> map brkf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bs-delta">
<h3><a class="doc-anchor" href="#doc-bs-delta">#</a> <code>bs_delta</code></h3>
<p><code>bs_delta</code> (aliases <code>bsdelta</code>, <code>option_delta</code>) computes the Black-Scholes delta (∂C/∂S). Args: S, K, T, r, sigma.</p>
<pre><code class="lang-perl">p bsdelta(100, 100, 1, 0.05, 0.2) # ≈ 0.64
</code></pre>
</article>
<article class="doc-entry" id="doc-bs-gamma">
<h3><a class="doc-anchor" href="#doc-bs-gamma">#</a> <code>bs_gamma</code></h3>
<p><code>bs_gamma</code> computes the Black-Scholes gamma (∂²C/∂S²). Measures convexity of option value.</p>
<pre><code class="lang-perl">p bsgamma(100, 100, 1, 0.05, 0.2) # ≈ 0.019
</code></pre>
</article>
<article class="doc-entry" id="doc-bs-rho">
<h3><a class="doc-anchor" href="#doc-bs-rho">#</a> <code>bs_rho</code></h3>
<p><code>bs_rho</code> computes the Black-Scholes rho (∂C/∂r). Sensitivity to interest rate.</p>
<pre><code class="lang-perl">p bsrho(100, 100, 1, 0.05, 0.2) # ≈ 46
</code></pre>
</article>
<article class="doc-entry" id="doc-bs-theta">
<h3><a class="doc-anchor" href="#doc-bs-theta">#</a> <code>bs_theta</code></h3>
<p><code>bs_theta</code> computes the Black-Scholes theta (∂C/∂t). Time decay per unit time.</p>
<pre><code class="lang-perl">p bstheta(100, 100, 1, 0.05, 0.2) # negative (time decay)
</code></pre>
</article>
<article class="doc-entry" id="doc-bs-vega">
<h3><a class="doc-anchor" href="#doc-bs-vega">#</a> <code>bs_vega</code></h3>
<p><code>bs_vega</code> computes the Black-Scholes vega (∂C/∂σ). Sensitivity to volatility.</p>
<pre><code class="lang-perl">p bsvega(100, 100, 1, 0.05, 0.2) # ≈ 37.5
</code></pre>
</article>
<article class="doc-entry" id="doc-bsearch">
<h3><a class="doc-anchor" href="#doc-bsearch">#</a> <code>bsearch</code></h3>
<p><code>bsearch</code> — collection (batch 2) builtin. Alias for <code>binary_search</code>.</p>
<pre><code class="lang-perl">my $result = bsearch $x
# or in a pipeline:
@list |> map bsearch |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bsize">
<h3><a class="doc-anchor" href="#doc-bsize">#</a> <code>bsize</code></h3>
<p><code>bsize</code> — misc / utility builtin. Alias for <code>byte_size</code>.</p>
<pre><code class="lang-perl">my $result = bsize $x
# or in a pipeline:
@list |> map bsize |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-btch">
<h3><a class="doc-anchor" href="#doc-btch">#</a> <code>btch</code></h3>
<p><code>btch</code> — additional missing stdlib functions builtin. Alias for <code>batched</code>.</p>
<pre><code class="lang-perl">my $result = btch $x
# or in a pipeline:
@list |> map btch |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bucket">
<h3><a class="doc-anchor" href="#doc-bucket">#</a> <code>bucket</code></h3>
<p><code>bucket</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = bucket $x
# or in a pipeline:
@list |> map bucket |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-butlast">
<h3><a class="doc-anchor" href="#doc-butlast">#</a> <code>butlast</code></h3>
<p><code>butlast</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = butlast $x
# or in a pipeline:
@list |> map butlast |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-byte-length">
<h3><a class="doc-anchor" href="#doc-byte-length">#</a> <code>byte_length</code></h3>
<p><code>byte_length</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = byte_length $x
# or in a pipeline:
@list |> map byte_length |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-byte-size">
<h3><a class="doc-anchor" href="#doc-byte-size">#</a> <code>byte_size</code></h3>
<p><code>byte_size</code> — misc / utility builtin.</p>
<pre><code class="lang-perl">my $result = byte_size $x
# or in a pipeline:
@list |> map byte_size |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-bytes-to-bits">
<h3><a class="doc-anchor" href="#doc-bytes-to-bits">#</a> <code>bytes_to_bits</code></h3>
<p><code>bytes_to_bits</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = bytes_to_bits $input
</code></pre>
</article>
<article class="doc-entry" id="doc-bytes-to-gb">
<h3><a class="doc-anchor" href="#doc-bytes-to-gb">#</a> <code>bytes_to_gb</code></h3>
<p><code>bytes_to_gb</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = bytes_to_gb $input
</code></pre>
</article>
<article class="doc-entry" id="doc-bytes-to-hex-str">
<h3><a class="doc-anchor" href="#doc-bytes-to-hex-str">#</a> <code>bytes_to_hex_str</code></h3>
<p><code>bytes_to_hex_str</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = bytes_to_hex_str $input
</code></pre>
</article>
<article class="doc-entry" id="doc-bytes-to-kb">
<h3><a class="doc-anchor" href="#doc-bytes-to-kb">#</a> <code>bytes_to_kb</code></h3>
<p><code>bytes_to_kb</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = bytes_to_kb $input
</code></pre>
</article>
<article class="doc-entry" id="doc-bytes-to-mb">
<h3><a class="doc-anchor" href="#doc-bytes-to-mb">#</a> <code>bytes_to_mb</code></h3>
<p><code>bytes_to_mb</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = bytes_to_mb $input
</code></pre>
</article>
<article class="doc-entry" id="doc-c">
<h3><a class="doc-anchor" href="#doc-c">#</a> <code>c</code></h3>
<p><code>c</code> — i/o extensions builtin.</p>
<pre><code class="lang-perl">my $result = c $x
# or in a pipeline:
@list |> map c |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-c256">
<h3><a class="doc-anchor" href="#doc-c256">#</a> <code>c256</code></h3>
<p><code>c256</code> — color / ansi builtin. Alias for <code>color256</code>.</p>
<pre><code class="lang-perl">my $result = c256 $x
# or in a pipeline:
@list |> map c256 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-c2s">
<h3><a class="doc-anchor" href="#doc-c2s">#</a> <code>c2s</code></h3>
<p><code>c2s</code> — string processing (uncategorized batch) builtin. Alias for <code>camel_to_snake</code>.</p>
<pre><code class="lang-perl">my $result = c2s $x
# or in a pipeline:
@list |> map c2s |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-c-to-f">
<h3><a class="doc-anchor" href="#doc-c-to-f">#</a> <code>c_to_f</code></h3>
<p><code>c_to_f</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = c_to_f $input
</code></pre>
</article>
<article class="doc-entry" id="doc-c-to-k">
<h3><a class="doc-anchor" href="#doc-c-to-k">#</a> <code>c_to_k</code></h3>
<p><code>c_to_k</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = c_to_k $input
</code></pre>
</article>
<article class="doc-entry" id="doc-caesar-shift">
<h3><a class="doc-anchor" href="#doc-caesar-shift">#</a> <code>caesar_shift</code></h3>
<p><code>caesar_shift</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = caesar_shift $x
# or in a pipeline:
@list |> map caesar_shift |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cagr">
<h3><a class="doc-anchor" href="#doc-cagr">#</a> <code>cagr</code></h3>
<p><code>cagr</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = cagr $x
# or in a pipeline:
@list |> map cagr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cal-to-joules">
<h3><a class="doc-anchor" href="#doc-cal-to-joules">#</a> <code>cal_to_joules</code></h3>
<p><code>cal_to_joules</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = cal_to_joules $input
</code></pre>
</article>
<article class="doc-entry" id="doc-camel-to-snake">
<h3><a class="doc-anchor" href="#doc-camel-to-snake">#</a> <code>camel_to_snake</code></h3>
<p><code>camel_to_snake</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = camel_to_snake $input
</code></pre>
</article>
<article class="doc-entry" id="doc-camel-words">
<h3><a class="doc-anchor" href="#doc-camel-words">#</a> <code>camel_words</code></h3>
<p><code>camel_words</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = camel_words $x
# or in a pipeline:
@list |> map camel_words |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cap">
<h3><a class="doc-anchor" href="#doc-cap">#</a> <code>cap</code></h3>
<p><code>cap</code> — trivial string ops builtin. Alias for <code>capitalize</code>.</p>
<pre><code class="lang-perl">my $result = cap $x
# or in a pipeline:
@list |> map cap |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-capacitance">
<h3><a class="doc-anchor" href="#doc-capacitance">#</a> <code>capacitance</code></h3>
<p><code>capacitance</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = capacitance $x
# or in a pipeline:
@list |> map capacitance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-capacitor-energy">
<h3><a class="doc-anchor" href="#doc-capacitor-energy">#</a> <code>capacitor_energy</code></h3>
<p><code>capacitor_energy</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = capacitor_energy $x
# or in a pipeline:
@list |> map capacitor_energy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-capenergy">
<h3><a class="doc-anchor" href="#doc-capenergy">#</a> <code>capenergy</code></h3>
<p><code>capenergy</code> — physics formulas builtin. Alias for <code>capacitor_energy</code>.</p>
<pre><code class="lang-perl">my $result = capenergy $x
# or in a pipeline:
@list |> map capenergy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-capg">
<h3><a class="doc-anchor" href="#doc-capg">#</a> <code>capg</code></h3>
<p><code>capg</code> — extended stdlib builtin. Alias for <code>capture_groups</code>.</p>
<pre><code class="lang-perl">my $result = capg $x
# or in a pipeline:
@list |> map capg |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-capitalize">
<h3><a class="doc-anchor" href="#doc-capitalize">#</a> <code>capitalize</code></h3>
<p><code>capitalize</code> — trivial string ops builtin.</p>
<pre><code class="lang-perl">my $result = capitalize $x
# or in a pipeline:
@list |> map capitalize |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-capm">
<h3><a class="doc-anchor" href="#doc-capm">#</a> <code>capm</code></h3>
<p><code>capm($risk_free, $beta, $market_return)</code> — computes expected return using the Capital Asset Pricing Model: rf + β(rm - rf).</p>
<pre><code class="lang-perl">p capm(0.02, 1.2, 0.08) # 9.2% expected return
</code></pre>
</article>
<article class="doc-entry" id="doc-capture-groups">
<h3><a class="doc-anchor" href="#doc-capture-groups">#</a> <code>capture_groups</code></h3>
<p><code>capture_groups</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = capture_groups $x
# or in a pipeline:
@list |> map capture_groups |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cartesian-power">
<h3><a class="doc-anchor" href="#doc-cartesian-power">#</a> <code>cartesian_power</code></h3>
<p><code>cartesian_power</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = cartesian_power $x
# or in a pipeline:
@list |> map cartesian_power |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cartesian-product">
<h3><a class="doc-anchor" href="#doc-cartesian-product">#</a> <code>cartesian_product</code></h3>
<p><code>cartesian_product</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = cartesian_product $x
# or in a pipeline:
@list |> map cartesian_product |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cartpow">
<h3><a class="doc-anchor" href="#doc-cartpow">#</a> <code>cartpow</code></h3>
<p><code>cartpow</code> — extended stdlib batch 3 builtin. Alias for <code>cartesian_power</code>.</p>
<pre><code class="lang-perl">my $result = cartpow $x
# or in a pipeline:
@list |> map cartpow |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cat">
<h3><a class="doc-anchor" href="#doc-cat">#</a> <code>cat</code></h3>
<p><code>cat</code> — i/o extensions builtin.</p>
<pre><code class="lang-perl">my $result = cat $x
# or in a pipeline:
@list |> map cat |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-catalan">
<h3><a class="doc-anchor" href="#doc-catalan">#</a> <code>catalan</code></h3>
<p><code>catalan_constant</code> (alias <code>catalan</code>) — Catalan's constant G ≈ 0.9159. Appears in combinatorics and series.</p>
<pre><code class="lang-perl">p catalan # 0.9159655941772190
</code></pre>
</article>
<article class="doc-entry" id="doc-catn">
<h3><a class="doc-anchor" href="#doc-catn">#</a> <code>catn</code></h3>
<p><code>catn</code> — extended stdlib batch 3 builtin. Alias for <code>catalan</code>.</p>
<pre><code class="lang-perl">my $result = catn $x
# or in a pipeline:
@list |> map catn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cauchy-pdf">
<h3><a class="doc-anchor" href="#doc-cauchy-pdf">#</a> <code>cauchy_pdf</code></h3>
<p><code>cauchy_pdf</code> (alias <code>cauchypdf</code>) evaluates the Cauchy distribution PDF at x with location x0 and scale gamma.</p>
<pre><code class="lang-perl">p cauchypdf(0, 0, 1) # peak of standard Cauchy
</code></pre>
</article>
<article class="doc-entry" id="doc-cbind">
<h3><a class="doc-anchor" href="#doc-cbind">#</a> <code>cbind</code></h3>
<p><code>cbind</code> — bind matrices by columns (horizontal join). Like R's cbind().</p>
<pre><code class="lang-perl">my $m = cbind([[1],[2]], [[3],[4]]) # [[1,3],[2,4]]
</code></pre>
</article>
<article class="doc-entry" id="doc-cblend">
<h3><a class="doc-anchor" href="#doc-cblend">#</a> <code>cblend</code></h3>
<p><code>cblend</code> — color operations builtin. Alias for <code>color_blend</code>.</p>
<pre><code class="lang-perl">my $result = cblend $x
# or in a pipeline:
@list |> map cblend |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cbrt">
<h3><a class="doc-anchor" href="#doc-cbrt">#</a> <code>cbrt</code></h3>
<p><code>cbrt</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = cbrt $x
# or in a pipeline:
@list |> map cbrt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ccgraph">
<h3><a class="doc-anchor" href="#doc-ccgraph">#</a> <code>ccgraph</code></h3>
<p><code>ccgraph</code> — extended stdlib builtin. Alias for <code>connected_components_graph</code>.</p>
<pre><code class="lang-perl">my $result = ccgraph $x
# or in a pipeline:
@list |> map ccgraph |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ccompl">
<h3><a class="doc-anchor" href="#doc-ccompl">#</a> <code>ccompl</code></h3>
<p><code>ccompl</code> — color operations builtin. Alias for <code>color_complement</code>.</p>
<pre><code class="lang-perl">my $result = ccompl $x
# or in a pipeline:
@list |> map ccompl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ccount">
<h3><a class="doc-anchor" href="#doc-ccount">#</a> <code>ccount</code></h3>
<p><code>ccount</code> — extended stdlib batch 3 builtin. Alias for <code>count_chars</code>.</p>
<pre><code class="lang-perl">my $result = ccount $x
# or in a pipeline:
@list |> map ccount |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cdarken">
<h3><a class="doc-anchor" href="#doc-cdarken">#</a> <code>cdarken</code></h3>
<p><code>cdarken</code> — color operations builtin. Alias for <code>color_darken</code>.</p>
<pre><code class="lang-perl">my $result = cdarken $x
# or in a pipeline:
@list |> map cdarken |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cdist">
<h3><a class="doc-anchor" href="#doc-cdist">#</a> <code>cdist</code></h3>
<p><code>cdist</code> — color operations builtin. Alias for <code>color_distance</code>.</p>
<pre><code class="lang-perl">my $result = cdist $x
# or in a pipeline:
@list |> map cdist |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ceil">
<h3><a class="doc-anchor" href="#doc-ceil">#</a> <code>ceil</code></h3>
<p><code>ceil</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = ceil $x
# or in a pipeline:
@list |> map ceil |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ceil-div">
<h3><a class="doc-anchor" href="#doc-ceil-div">#</a> <code>ceil_div</code></h3>
<p><code>ceil_div</code> — trig / math (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = ceil_div $x
# or in a pipeline:
@list |> map ceil_div |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ceil-each">
<h3><a class="doc-anchor" href="#doc-ceil-each">#</a> <code>ceil_each</code></h3>
<p><code>ceil_each</code> — trivial numeric helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = ceil_each $x
# or in a pipeline:
@list |> map ceil_each |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ceiling">
<h3><a class="doc-anchor" href="#doc-ceiling">#</a> <code>ceiling</code></h3>
<p><code>ceiling</code> — trivial numeric / predicate builtins builtin. Alias for <code>ceil</code>.</p>
<pre><code class="lang-perl">my $result = ceiling $x
# or in a pipeline:
@list |> map ceiling |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-center">
<h3><a class="doc-anchor" href="#doc-center">#</a> <code>center</code></h3>
<p><code>center</code> — trivial string ops builtin.</p>
<pre><code class="lang-perl">my $result = center $x
# or in a pipeline:
@list |> map center |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-center-text">
<h3><a class="doc-anchor" href="#doc-center-text">#</a> <code>center_text</code></h3>
<p><code>center_text</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = center_text $x
# or in a pipeline:
@list |> map center_text |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-centrip">
<h3><a class="doc-anchor" href="#doc-centrip">#</a> <code>centrip</code></h3>
<p><code>centripetal_force($mass, $velocity, $radius)</code> (alias <code>centrip</code>) — F = mv²/r for circular motion.</p>
<pre><code class="lang-perl">p centrip(1000, 20, 50) # 8000 N (car turning)
</code></pre>
</article>
<article class="doc-entry" id="doc-centroid">
<h3><a class="doc-anchor" href="#doc-centroid">#</a> <code>centroid</code></h3>
<p><code>centroid(@points)</code> — computes the centroid (geometric center) of 2D points. Points as flat list [x1,y1,x2,y2,...]. Returns [$cx, $cy].</p>
<pre><code class="lang-perl">my @triangle = (0,0, 3,0, 0,3)
my $c = centroid(@triangle)
p @$c # (1, 1)
</code></pre>
</article>
<article class="doc-entry" id="doc-cgray">
<h3><a class="doc-anchor" href="#doc-cgray">#</a> <code>cgray</code></h3>
<p><code>cgray</code> — color operations builtin. Alias for <code>color_grayscale</code>.</p>
<pre><code class="lang-perl">my $result = cgray $x
# or in a pipeline:
@list |> map cgray |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chain-from">
<h3><a class="doc-anchor" href="#doc-chain-from">#</a> <code>chain_from</code></h3>
<p><code>chain_from</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = chain_from $x
# or in a pipeline:
@list |> map chain_from |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-char-at">
<h3><a class="doc-anchor" href="#doc-char-at">#</a> <code>char_at</code></h3>
<p><code>char_at</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = char_at $x
# or in a pipeline:
@list |> map char_at |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-char-count">
<h3><a class="doc-anchor" href="#doc-char-count">#</a> <code>char_count</code></h3>
<p><code>char_count</code> — trivial string ops builtin.</p>
<pre><code class="lang-perl">my $result = char_count $x
# or in a pipeline:
@list |> map char_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-char-devices">
<h3><a class="doc-anchor" href="#doc-char-devices">#</a> <code>char_devices</code></h3>
<p><code>char_devices</code> — filesystem extensions builtin.</p>
<pre><code class="lang-perl">my $result = char_devices $x
# or in a pipeline:
@list |> map char_devices |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-char-frequencies">
<h3><a class="doc-anchor" href="#doc-char-frequencies">#</a> <code>char_frequencies</code></h3>
<p><code>char_frequencies</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = char_frequencies $x
# or in a pipeline:
@list |> map char_frequencies |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-char-length">
<h3><a class="doc-anchor" href="#doc-char-length">#</a> <code>char_length</code></h3>
<p><code>char_length</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = char_length $x
# or in a pipeline:
@list |> map char_length |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-charfreq">
<h3><a class="doc-anchor" href="#doc-charfreq">#</a> <code>charfreq</code></h3>
<p><code>charfreq</code> — string processing (uncategorized batch) builtin. Alias for <code>char_frequencies</code>.</p>
<pre><code class="lang-perl">my $result = charfreq $x
# or in a pipeline:
@list |> map charfreq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chars-to-string">
<h3><a class="doc-anchor" href="#doc-chars-to-string">#</a> <code>chars_to_string</code></h3>
<p><code>chars_to_string</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = chars_to_string $input
</code></pre>
</article>
<article class="doc-entry" id="doc-chat">
<h3><a class="doc-anchor" href="#doc-chat">#</a> <code>chat</code></h3>
<p><code>chat</code> — extended stdlib builtin. Alias for <code>char_at</code>.</p>
<pre><code class="lang-perl">my $result = chat $x
# or in a pipeline:
@list |> map chat |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chebyshev-distance">
<h3><a class="doc-anchor" href="#doc-chebyshev-distance">#</a> <code>chebyshev_distance</code></h3>
<p><code>chebyshev_distance</code> — math functions builtin.</p>
<pre><code class="lang-perl">my $result = chebyshev_distance $x
# or in a pipeline:
@list |> map chebyshev_distance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chfr">
<h3><a class="doc-anchor" href="#doc-chfr">#</a> <code>chfr</code></h3>
<p><code>chfr</code> — python/ruby stdlib builtin. Alias for <code>chain_from</code>.</p>
<pre><code class="lang-perl">my $result = chfr $x
# or in a pipeline:
@list |> map chfr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chi2">
<h3><a class="doc-anchor" href="#doc-chi2">#</a> <code>chi2</code></h3>
<p><code>chi_square_stat(\@observed, \@expected)</code> (alias <code>chi2</code>) — computes the chi-squared test statistic comparing observed vs expected frequencies. Useful for goodness-of-fit tests. Returns the chi-squared value.</p>
<pre><code class="lang-perl">my @obs = (10, 20, 30)
my @exp = (15, 20, 25)
p chi2(\@obs, \@exp) # chi-squared statistic
</code></pre>
</article>
<article class="doc-entry" id="doc-chi2-pdf">
<h3><a class="doc-anchor" href="#doc-chi2-pdf">#</a> <code>chi2_pdf</code></h3>
<p><code>chi2_pdf</code> (alias <code>chi2pdf</code>) evaluates the chi-squared distribution PDF at x with k degrees of freedom.</p>
<pre><code class="lang-perl">p chi2pdf(3.84, 1) # p-value boundary for df=1
</code></pre>
</article>
<article class="doc-entry" id="doc-chinese-remainder">
<h3><a class="doc-anchor" href="#doc-chinese-remainder">#</a> <code>chinese_remainder</code></h3>
<p><code>chinese_remainder</code> (alias <code>crt</code>) solves a system of simultaneous congruences via the Chinese Remainder Theorem.</p>
<pre><code class="lang-perl">p crt([2,3,2], [3,5,7]) # 23 (x≡2 mod 3, x≡3 mod 5, x≡2 mod 7)
</code></pre>
</article>
<article class="doc-entry" id="doc-chirp">
<h3><a class="doc-anchor" href="#doc-chirp">#</a> <code>chirp</code></h3>
<p><code>chirp</code> generates a linear chirp signal sweeping from f0 to f1 Hz. Args: n_samples, f0, f1, sample_rate.</p>
<pre><code class="lang-perl">my @sig = @{chirp(1000, 100, 1000, 8000)}
</code></pre>
</article>
<article class="doc-entry" id="doc-chkstr">
<h3><a class="doc-anchor" href="#doc-chkstr">#</a> <code>chkstr</code></h3>
<p><code>chkstr</code> — string processing (uncategorized batch) builtin. Alias for <code>chunk_string</code>.</p>
<pre><code class="lang-perl">my $result = chkstr $x
# or in a pipeline:
@list |> map chkstr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chkw">
<h3><a class="doc-anchor" href="#doc-chkw">#</a> <code>chkw</code></h3>
<p><code>chkw</code> — ruby enumerable extras builtin. Alias for <code>chunk_while</code>.</p>
<pre><code class="lang-perl">my $result = chkw $x
# or in a pipeline:
@list |> map chkw |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cholesky">
<h3><a class="doc-anchor" href="#doc-cholesky">#</a> <code>cholesky</code></h3>
<p><code>matrix_cholesky</code> (aliases <code>mchol</code>, <code>cholesky</code>) computes the Cholesky decomposition of a symmetric positive-definite matrix. Returns lower-triangular L where M = L·L^T.</p>
<pre><code class="lang-perl">my $L = cholesky([[4,2],[2,3]])
</code></pre>
</article>
<article class="doc-entry" id="doc-chomp-str">
<h3><a class="doc-anchor" href="#doc-chomp-str">#</a> <code>chomp_str</code></h3>
<p><code>chomp_str</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = chomp_str $x
# or in a pipeline:
@list |> map chomp_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chop-str">
<h3><a class="doc-anchor" href="#doc-chop-str">#</a> <code>chop_str</code></h3>
<p><code>chop_str</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = chop_str $x
# or in a pipeline:
@list |> map chop_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chroot">
<h3><a class="doc-anchor" href="#doc-chroot">#</a> <code>chroot</code></h3>
<p><code>chroot</code> — process / system builtin.</p>
<pre><code class="lang-perl">my $result = chroot $x
# or in a pipeline:
@list |> map chroot |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chull">
<h3><a class="doc-anchor" href="#doc-chull">#</a> <code>chull</code></h3>
<p><code>convex_hull(@points)</code> (alias <code>chull</code>) — computes the convex hull of a set of 2D points. Points given as flat list [x1,y1,x2,y2,...]. Returns the hull vertices in counterclockwise order. Uses Graham scan algorithm.</p>
<pre><code class="lang-perl">my @pts = (0,0, 1,1, 2,0, 1,0.5)
my $hull = chull(@pts)
p @$hull
</code></pre>
</article>
<article class="doc-entry" id="doc-chunk-by">
<h3><a class="doc-anchor" href="#doc-chunk-by">#</a> <code>chunk_by</code></h3>
<p><code>chunk_by</code> — functional / iterator builtin.</p>
<pre><code class="lang-perl">my $result = chunk_by $x
# or in a pipeline:
@list |> map chunk_by |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chunk-n">
<h3><a class="doc-anchor" href="#doc-chunk-n">#</a> <code>chunk_n</code></h3>
<p><code>chunk_n</code> — collection (batch 2) builtin. Alias for <code>group_of_n</code>.</p>
<pre><code class="lang-perl">my $result = chunk_n $x
# or in a pipeline:
@list |> map chunk_n |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chunk-string">
<h3><a class="doc-anchor" href="#doc-chunk-string">#</a> <code>chunk_string</code></h3>
<p><code>chunk_string</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = chunk_string $x
# or in a pipeline:
@list |> map chunk_string |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-chunk-while">
<h3><a class="doc-anchor" href="#doc-chunk-while">#</a> <code>chunk_while</code></h3>
<p><code>chunk_while</code> — ruby enumerable extras builtin.</p>
<pre><code class="lang-perl">my $result = chunk_while $x
# or in a pipeline:
@list |> map chunk_while |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ci">
<h3><a class="doc-anchor" href="#doc-ci">#</a> <code>ci</code></h3>
<p><code>confidence_interval</code> (alias <code>ci</code>) computes a confidence interval for the mean. Default 95%. Returns [lower, upper].</p>
<pre><code class="lang-perl">my ($lo, $hi) = @{ci([10,12,14,11,13])}
p "95%% CI: $lo to $hi"
my ($lo99, $hi99) = @{ci([10,12,14,11,13], 0.99)}
</code></pre>
</article>
<article class="doc-entry" id="doc-cinv">
<h3><a class="doc-anchor" href="#doc-cinv">#</a> <code>cinv</code></h3>
<p><code>cinv</code> — extended stdlib batch 3 builtin. Alias for <code>count_inversions</code>.</p>
<pre><code class="lang-perl">my $result = cinv $x
# or in a pipeline:
@list |> map cinv |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cinvert">
<h3><a class="doc-anchor" href="#doc-cinvert">#</a> <code>cinvert</code></h3>
<p><code>cinvert</code> — color operations builtin. Alias for <code>color_invert</code>.</p>
<pre><code class="lang-perl">my $result = cinvert $x
# or in a pipeline:
@list |> map cinvert |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-circ3pt">
<h3><a class="doc-anchor" href="#doc-circ3pt">#</a> <code>circ3pt</code></h3>
<p><code>circ3pt</code> — geometry (extended) builtin. Alias for <code>circle_from_three_points</code>.</p>
<pre><code class="lang-perl">my $result = circ3pt $x
# or in a pipeline:
@list |> map circ3pt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-circle-from-three-points">
<h3><a class="doc-anchor" href="#doc-circle-from-three-points">#</a> <code>circle_from_three_points</code></h3>
<p><code>circle_from_three_points($x1, $y1, $x2, $y2, $x3, $y3)</code> (alias <code>circ3</code>) — finds the unique circle passing through three non-collinear points. Returns [$cx, $cy, $radius] or undef if collinear.</p>
<pre><code class="lang-perl">my $c = circ3(0, 0, 1, 0, 0.5, 0.866)
p "center=($c->[0], $c->[1]) r=$c->[2]"
</code></pre>
</article>
<article class="doc-entry" id="doc-circum">
<h3><a class="doc-anchor" href="#doc-circum">#</a> <code>circum</code></h3>
<p><code>circum</code> — geometry / physics builtin. Alias for <code>circumference</code>.</p>
<pre><code class="lang-perl">my $result = circum $x
# or in a pipeline:
@list |> map circum |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-circumference">
<h3><a class="doc-anchor" href="#doc-circumference">#</a> <code>circumference</code></h3>
<p><code>circumference</code> — geometry / physics builtin.</p>
<pre><code class="lang-perl">my $result = circumference $x
# or in a pipeline:
@list |> map circumference |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-clamp-array">
<h3><a class="doc-anchor" href="#doc-clamp-array">#</a> <code>clamp_array</code></h3>
<p><code>clamp_array</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = clamp_array $x
# or in a pipeline:
@list |> map clamp_array |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-clamp-each">
<h3><a class="doc-anchor" href="#doc-clamp-each">#</a> <code>clamp_each</code></h3>
<p><code>clamp_each</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = clamp_each $x
# or in a pipeline:
@list |> map clamp_each |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-clamp-fn">
<h3><a class="doc-anchor" href="#doc-clamp-fn">#</a> <code>clamp_fn</code></h3>
<p><code>clamp_fn</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = clamp_fn $x
# or in a pipeline:
@list |> map clamp_fn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-clamp-int">
<h3><a class="doc-anchor" href="#doc-clamp-int">#</a> <code>clamp_int</code></h3>
<p><code>clamp_int</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = clamp_int $x
# or in a pipeline:
@list |> map clamp_int |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-clamp-list">
<h3><a class="doc-anchor" href="#doc-clamp-list">#</a> <code>clamp_list</code></h3>
<p><code>clamp_list</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = clamp_list $x
# or in a pipeline:
@list |> map clamp_list |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-clarr">
<h3><a class="doc-anchor" href="#doc-clarr">#</a> <code>clarr</code></h3>
<p><code>clarr</code> — matrix operations (uncategorized batch) builtin. Alias for <code>clamp_array</code>.</p>
<pre><code class="lang-perl">my $result = clarr $x
# or in a pipeline:
@list |> map clarr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-clighten">
<h3><a class="doc-anchor" href="#doc-clighten">#</a> <code>clighten</code></h3>
<p><code>clighten</code> — color operations builtin. Alias for <code>color_lighten</code>.</p>
<pre><code class="lang-perl">my $result = clighten $x
# or in a pipeline:
@list |> map clighten |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-clpi">
<h3><a class="doc-anchor" href="#doc-clpi">#</a> <code>clpi</code></h3>
<p><code>clpi</code> — extended stdlib builtin. Alias for <code>clamp_int</code>.</p>
<pre><code class="lang-perl">my $result = clpi $x
# or in a pipeline:
@list |> map clpi |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cm-to-inches">
<h3><a class="doc-anchor" href="#doc-cm-to-inches">#</a> <code>cm_to_inches</code></h3>
<p><code>cm_to_inches</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = cm_to_inches $input
</code></pre>
</article>
<article class="doc-entry" id="doc-cmap">
<h3><a class="doc-anchor" href="#doc-cmap">#</a> <code>cmap</code></h3>
<p><code>cmap</code> — additional missing stdlib functions builtin. Alias for <code>concat_map</code>.</p>
<pre><code class="lang-perl">my $result = cmap $x
# or in a pipeline:
@list |> map cmap |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cmd-exists">
<h3><a class="doc-anchor" href="#doc-cmd-exists">#</a> <code>cmd_exists</code></h3>
<p><code>cmd_exists</code> — process / env builtin.</p>
<pre><code class="lang-perl">my $result = cmd_exists $x
# or in a pipeline:
@list |> map cmd_exists |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cmp-num">
<h3><a class="doc-anchor" href="#doc-cmp-num">#</a> <code>cmp_num</code></h3>
<p><code>cmp_num</code> — file stat / path builtin. Alias for <code>spaceship</code>.</p>
<pre><code class="lang-perl">my $result = cmp_num $x
# or in a pipeline:
@list |> map cmp_num |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cmp-str">
<h3><a class="doc-anchor" href="#doc-cmp-str">#</a> <code>cmp_str</code></h3>
<p><code>cmp_str</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = cmp_str $x
# or in a pipeline:
@list |> map cmp_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cmpr">
<h3><a class="doc-anchor" href="#doc-cmpr">#</a> <code>cmpr</code></h3>
<p><code>cmpr</code> — python/ruby stdlib builtin. Alias for <code>compress</code>.</p>
<pre><code class="lang-perl">my $result = cmpr $x
# or in a pipeline:
@list |> map cmpr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cnt">
<h3><a class="doc-anchor" href="#doc-cnt">#</a> <code>cnt</code></h3>
<p><code>count</code> (aliases <code>len</code>, <code>cnt</code>) returns the number of elements in a list, the number of characters in a string, the number of key-value pairs in a hash, or the cardinality of a set. It is a universal length function that dispatches based on the type of its argument. This replaces the need to use <code>scalar @array</code> or <code>length $string</code> — <code>cnt</code> is shorter and works uniformly across types. In a pipeline, it naturally reduces a collection to a single number.</p>
<p>Note: <code>size</code> is NOT a count alias — it returns a file's byte size (see <code>size</code>).</p>
<pre><code class="lang-perl">my @arr = (1, 2, 3, 4, 5)
p cnt @arr # 5
p len "hello" # 5
my %h = (a => 1, b => 2)
p cnt \%h # 2
rl("file.txt") |> cnt |> p # line count
</code></pre>
</article>
<article class="doc-entry" id="doc-cntw">
<h3><a class="doc-anchor" href="#doc-cntw">#</a> <code>cntw</code></h3>
<p><code>cntw</code> — ruby enumerable extras builtin. Alias for <code>count_while</code>.</p>
<pre><code class="lang-perl">my $result = cntw $x
# or in a pipeline:
@list |> map cntw |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-coalesce">
<h3><a class="doc-anchor" href="#doc-coalesce">#</a> <code>coalesce</code></h3>
<p><code>coalesce</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = coalesce $x
# or in a pipeline:
@list |> map coalesce |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-code-point-at">
<h3><a class="doc-anchor" href="#doc-code-point-at">#</a> <code>code_point_at</code></h3>
<p><code>code_point_at</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = code_point_at $x
# or in a pipeline:
@list |> map code_point_at |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-coeff-of-variation">
<h3><a class="doc-anchor" href="#doc-coeff-of-variation">#</a> <code>coeff_of_variation</code></h3>
<p><code>coeff_of_variation</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = coeff_of_variation $x
# or in a pipeline:
@list |> map coeff_of_variation |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cohen-d">
<h3><a class="doc-anchor" href="#doc-cohen-d">#</a> <code>cohen_d</code></h3>
<p><code>cohen_d</code> (alias <code>cohend</code>) computes Cohen's d effect size between two samples. Small=0.2, medium=0.5, large=0.8.</p>
<pre><code class="lang-perl">p cohend([1,2,3], [4,5,6]) # large effect
</code></pre>
</article>
<article class="doc-entry" id="doc-coin-flip">
<h3><a class="doc-anchor" href="#doc-coin-flip">#</a> <code>coin_flip</code></h3>
<p><code>coin_flip</code> — random builtin.</p>
<pre><code class="lang-perl">my $result = coin_flip $x
# or in a pipeline:
@list |> map coin_flip |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-colmeans">
<h3><a class="doc-anchor" href="#doc-colmeans">#</a> <code>colMeans</code></h3>
<p><code>col_means</code> (alias <code>colMeans</code>) — mean of each column. Like R's colMeans().</p>
<pre><code class="lang-perl">p colMeans([[2,4],[6,8]]) # [4, 6]
</code></pre>
</article>
<article class="doc-entry" id="doc-colsums">
<h3><a class="doc-anchor" href="#doc-colsums">#</a> <code>colSums</code></h3>
<p><code>col_sums</code> (alias <code>colSums</code>) — sum of each column. Like R's colSums().</p>
<pre><code class="lang-perl">p colSums([[1,2],[3,4]]) # [4, 6]
</code></pre>
</article>
<article class="doc-entry" id="doc-collapse-whitespace">
<h3><a class="doc-anchor" href="#doc-collapse-whitespace">#</a> <code>collapse_whitespace</code></h3>
<p><code>collapse_whitespace</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = collapse_whitespace $x
# or in a pipeline:
@list |> map collapse_whitespace |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-collatz">
<h3><a class="doc-anchor" href="#doc-collatz">#</a> <code>collatz</code></h3>
<p><code>collatz</code> — math / numeric (uncategorized batch) builtin. Alias for <code>collatz_length</code>.</p>
<pre><code class="lang-perl">my $result = collatz $x
# or in a pipeline:
@list |> map collatz |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-collatz-length">
<h3><a class="doc-anchor" href="#doc-collatz-length">#</a> <code>collatz_length</code></h3>
<p><code>collatz_length</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = collatz_length $x
# or in a pipeline:
@list |> map collatz_length |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-collatz-sequence">
<h3><a class="doc-anchor" href="#doc-collatz-sequence">#</a> <code>collatz_sequence</code></h3>
<p><code>collatz_sequence</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = collatz_sequence $x
# or in a pipeline:
@list |> map collatz_sequence |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-collatzseq">
<h3><a class="doc-anchor" href="#doc-collatzseq">#</a> <code>collatzseq</code></h3>
<p><code>collatzseq</code> — math / numeric (uncategorized batch) builtin. Alias for <code>collatz_sequence</code>.</p>
<pre><code class="lang-perl">my $result = collatzseq $x
# or in a pipeline:
@list |> map collatzseq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-collws">
<h3><a class="doc-anchor" href="#doc-collws">#</a> <code>collws</code></h3>
<p><code>collws</code> — string processing (uncategorized batch) builtin. Alias for <code>collapse_whitespace</code>.</p>
<pre><code class="lang-perl">my $result = collws $x
# or in a pipeline:
@list |> map collws |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-color256">
<h3><a class="doc-anchor" href="#doc-color256">#</a> <code>color256</code></h3>
<p><code>color256</code> — color / ansi builtin.</p>
<pre><code class="lang-perl">my $result = color256 $x
# or in a pipeline:
@list |> map color256 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-color-blend">
<h3><a class="doc-anchor" href="#doc-color-blend">#</a> <code>color_blend</code></h3>
<p><code>color_blend</code> — color operations builtin.</p>
<pre><code class="lang-perl">my $result = color_blend $x
# or in a pipeline:
@list |> map color_blend |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-color-complement">
<h3><a class="doc-anchor" href="#doc-color-complement">#</a> <code>color_complement</code></h3>
<p><code>color_complement</code> — color operations builtin.</p>
<pre><code class="lang-perl">my $result = color_complement $x
# or in a pipeline:
@list |> map color_complement |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-color-darken">
<h3><a class="doc-anchor" href="#doc-color-darken">#</a> <code>color_darken</code></h3>
<p><code>color_darken</code> — color operations builtin.</p>
<pre><code class="lang-perl">my $result = color_darken $x
# or in a pipeline:
@list |> map color_darken |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-color-distance">
<h3><a class="doc-anchor" href="#doc-color-distance">#</a> <code>color_distance</code></h3>
<p><code>color_distance</code> — color operations builtin.</p>
<pre><code class="lang-perl">my $result = color_distance $x
# or in a pipeline:
@list |> map color_distance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-color-grayscale">
<h3><a class="doc-anchor" href="#doc-color-grayscale">#</a> <code>color_grayscale</code></h3>
<p><code>color_grayscale</code> — color operations builtin.</p>
<pre><code class="lang-perl">my $result = color_grayscale $x
# or in a pipeline:
@list |> map color_grayscale |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-color-invert">
<h3><a class="doc-anchor" href="#doc-color-invert">#</a> <code>color_invert</code></h3>
<p><code>color_invert</code> — color operations builtin.</p>
<pre><code class="lang-perl">my $result = color_invert $x
# or in a pipeline:
@list |> map color_invert |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-color-lighten">
<h3><a class="doc-anchor" href="#doc-color-lighten">#</a> <code>color_lighten</code></h3>
<p><code>color_lighten</code> — color operations builtin.</p>
<pre><code class="lang-perl">my $result = color_lighten $x
# or in a pipeline:
@list |> map color_lighten |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-comb">
<h3><a class="doc-anchor" href="#doc-comb">#</a> <code>comb</code></h3>
<p><code>combinations($n, $r)</code> (alias <code>comb</code>) — number of ways to choose r items from n. Formula: n!/(r!(n-r)!). Order doesn't matter.</p>
<pre><code class="lang-perl">p comb(5, 3) # 10 (ways to choose 3 items from 5)
p comb(52, 5) # 2598960 (poker hands)
</code></pre>
</article>
<article class="doc-entry" id="doc-combinations-rep">
<h3><a class="doc-anchor" href="#doc-combinations-rep">#</a> <code>combinations_rep</code></h3>
<p><code>combinations_rep</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = combinations_rep $x
# or in a pipeline:
@list |> map combinations_rep |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-combrep">
<h3><a class="doc-anchor" href="#doc-combrep">#</a> <code>combrep</code></h3>
<p><code>combrep</code> — additional missing stdlib functions builtin. Alias for <code>combinations_rep</code>.</p>
<pre><code class="lang-perl">my $result = combrep $x
# or in a pipeline:
@list |> map combrep |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-common-prefix">
<h3><a class="doc-anchor" href="#doc-common-prefix">#</a> <code>common_prefix</code></h3>
<p><code>common_prefix</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = common_prefix $x
# or in a pipeline:
@list |> map common_prefix |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-common-suffix">
<h3><a class="doc-anchor" href="#doc-common-suffix">#</a> <code>common_suffix</code></h3>
<p><code>common_suffix</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = common_suffix $x
# or in a pipeline:
@list |> map common_suffix |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-compare-versions">
<h3><a class="doc-anchor" href="#doc-compare-versions">#</a> <code>compare_versions</code></h3>
<p><code>compare_versions</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = compare_versions $x
# or in a pipeline:
@list |> map compare_versions |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-compound-interest">
<h3><a class="doc-anchor" href="#doc-compound-interest">#</a> <code>compound_interest</code></h3>
<p><code>compound_interest</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = compound_interest $x
# or in a pipeline:
@list |> map compound_interest |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-compress">
<h3><a class="doc-anchor" href="#doc-compress">#</a> <code>compress</code></h3>
<p><code>compress</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = compress $x
# or in a pipeline:
@list |> map compress |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-concat-map">
<h3><a class="doc-anchor" href="#doc-concat-map">#</a> <code>concat_map</code></h3>
<p><code>concat_map</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = concat_map $x
# or in a pipeline:
@list |> map concat_map |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cond">
<h3><a class="doc-anchor" href="#doc-cond">#</a> <code>cond</code></h3>
<p><code>matrix_cond</code> (aliases <code>mcond</code>, <code>cond</code>) estimates the condition number of a matrix (ratio of largest to smallest singular value). Large values indicate ill-conditioning.</p>
<pre><code class="lang-perl">p cond([[1,0],[0,1]]) # 1 (perfect)
p cond([[1,2],[2,4]]) # Inf (singular)
</code></pre>
</article>
<article class="doc-entry" id="doc-cone-volume">
<h3><a class="doc-anchor" href="#doc-cone-volume">#</a> <code>cone_volume</code></h3>
<p><code>cone_volume</code> — geometry / physics builtin.</p>
<pre><code class="lang-perl">my $result = cone_volume $x
# or in a pipeline:
@list |> map cone_volume |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-conevol">
<h3><a class="doc-anchor" href="#doc-conevol">#</a> <code>conevol</code></h3>
<p><code>conevol</code> — geometry / physics builtin. Alias for <code>cone_volume</code>.</p>
<pre><code class="lang-perl">my $result = conevol $x
# or in a pipeline:
@list |> map conevol |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-confint">
<h3><a class="doc-anchor" href="#doc-confint">#</a> <code>confint</code></h3>
<p><code>confint_lm</code> (alias <code>confint</code>) — confidence intervals for model coefficients. Returns hash with intercept_lower/upper, slope_lower/upper.</p>
<pre><code class="lang-perl">my $ci = confint(lm([1,2,3,4,5], [2,4,5,4,5]))
p $ci->{slope_lower}
</code></pre>
</article>
<article class="doc-entry" id="doc-conj">
<h3><a class="doc-anchor" href="#doc-conj">#</a> <code>conj</code></h3>
<p><code>conj</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = conj $x
# or in a pipeline:
@list |> map conj |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-connected-components-graph">
<h3><a class="doc-anchor" href="#doc-connected-components-graph">#</a> <code>connected_components_graph</code></h3>
<p><code>connected_components_graph</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = connected_components_graph $x
# or in a pipeline:
@list |> map connected_components_graph |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cons">
<h3><a class="doc-anchor" href="#doc-cons">#</a> <code>cons</code></h3>
<p><code>cons</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = cons $x
# or in a pipeline:
@list |> map cons |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-consecutive-eq">
<h3><a class="doc-anchor" href="#doc-consecutive-eq">#</a> <code>consecutive_eq</code></h3>
<p><code>consecutive_eq</code> — collection more builtin.</p>
<pre><code class="lang-perl">my $result = consecutive_eq $x
# or in a pipeline:
@list |> map consecutive_eq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-consecutive-pairs">
<h3><a class="doc-anchor" href="#doc-consecutive-pairs">#</a> <code>consecutive_pairs</code></h3>
<p><code>consecutive_pairs</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = consecutive_pairs $x
# or in a pipeline:
@list |> map consecutive_pairs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-const-fn">
<h3><a class="doc-anchor" href="#doc-const-fn">#</a> <code>const_fn</code></h3>
<p><code>const_fn</code> — functional primitives builtin.</p>
<pre><code class="lang-perl">my $result = const_fn $x
# or in a pipeline:
@list |> map const_fn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-constant-case">
<h3><a class="doc-anchor" href="#doc-constant-case">#</a> <code>constant_case</code></h3>
<p><code>constant_case</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = constant_case $x
# or in a pipeline:
@list |> map constant_case |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-contains">
<h3><a class="doc-anchor" href="#doc-contains">#</a> <code>contains</code></h3>
<p><code>contains</code> — trivial string ops builtin.</p>
<pre><code class="lang-perl">my $result = contains $x
# or in a pipeline:
@list |> map contains |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-contains-all">
<h3><a class="doc-anchor" href="#doc-contains-all">#</a> <code>contains_all</code></h3>
<p><code>contains_all</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = contains_all $x
# or in a pipeline:
@list |> map contains_all |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-contains-any">
<h3><a class="doc-anchor" href="#doc-contains-any">#</a> <code>contains_any</code></h3>
<p><code>contains_any</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = contains_any $x
# or in a pipeline:
@list |> map contains_any |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-contains-elem">
<h3><a class="doc-anchor" href="#doc-contains-elem">#</a> <code>contains_elem</code></h3>
<p><code>contains_elem</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = contains_elem $x
# or in a pipeline:
@list |> map contains_elem |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-contcomp">
<h3><a class="doc-anchor" href="#doc-contcomp">#</a> <code>contcomp</code></h3>
<p><code>contcomp</code> — finance (extended) builtin. Alias for <code>continuous_compound</code>.</p>
<pre><code class="lang-perl">my $result = contcomp $x
# or in a pipeline:
@list |> map contcomp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-continuous-compound">
<h3><a class="doc-anchor" href="#doc-continuous-compound">#</a> <code>continuous_compound</code></h3>
<p><code>continuous_compound($principal, $rate, $time)</code> (alias <code>ccomp</code>) — computes future value with continuous compounding: P × e^(rt).</p>
<pre><code class="lang-perl">p ccomp(1000, 0.05, 10) # ~1648.72
</code></pre>
</article>
<article class="doc-entry" id="doc-conv">
<h3><a class="doc-anchor" href="#doc-conv">#</a> <code>conv</code></h3>
<p><code>conv</code> — math / numeric (uncategorized batch) builtin. Alias for <code>convolution</code>.</p>
<pre><code class="lang-perl">my $result = conv $x
# or in a pipeline:
@list |> map conv |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-converge">
<h3><a class="doc-anchor" href="#doc-converge">#</a> <code>converge</code></h3>
<p><code>converge</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = converge $x
# or in a pipeline:
@list |> map converge |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-convolution">
<h3><a class="doc-anchor" href="#doc-convolution">#</a> <code>convolution</code></h3>
<p><code>convolution</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = convolution $x
# or in a pipeline:
@list |> map convolution |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-copy-sign">
<h3><a class="doc-anchor" href="#doc-copy-sign">#</a> <code>copy_sign</code></h3>
<p><code>copy_sign</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = copy_sign $x
# or in a pipeline:
@list |> map copy_sign |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-copy-within">
<h3><a class="doc-anchor" href="#doc-copy-within">#</a> <code>copy_within</code></h3>
<p><code>copy_within</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = copy_within $x
# or in a pipeline:
@list |> map copy_within |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-copysign">
<h3><a class="doc-anchor" href="#doc-copysign">#</a> <code>copysign</code></h3>
<p><code>copysign</code> — math functions builtin.</p>
<pre><code class="lang-perl">my $result = copysign $x
# or in a pipeline:
@list |> map copysign |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cor-mat">
<h3><a class="doc-anchor" href="#doc-cor-mat">#</a> <code>cor_mat</code></h3>
<p><code>cor_matrix</code> (alias <code>cor_mat</code>) — correlation matrix from observations. Each row is an observation vector.</p>
<pre><code class="lang-perl">my $R = cor_mat([[1,2],[3,4],[5,6]]) # 2x2 correlation matrix
</code></pre>
</article>
<article class="doc-entry" id="doc-corr">
<h3><a class="doc-anchor" href="#doc-corr">#</a> <code>corr</code></h3>
<p><code>corr</code> — extended stdlib builtin. Alias for <code>correlation</code>.</p>
<pre><code class="lang-perl">my $result = corr $x
# or in a pipeline:
@list |> map corr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-correlation">
<h3><a class="doc-anchor" href="#doc-correlation">#</a> <code>correlation</code></h3>
<p><code>correlation</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = correlation $x
# or in a pipeline:
@list |> map correlation |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cosh">
<h3><a class="doc-anchor" href="#doc-cosh">#</a> <code>cosh</code></h3>
<p><code>cosh</code> — trig / math (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = cosh $x
# or in a pipeline:
@list |> map cosh |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cosine-similarity">
<h3><a class="doc-anchor" href="#doc-cosine-similarity">#</a> <code>cosine_similarity</code></h3>
<p><code>cosine_similarity</code> — math functions builtin.</p>
<pre><code class="lang-perl">my $result = cosine_similarity $x
# or in a pipeline:
@list |> map cosine_similarity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cot">
<h3><a class="doc-anchor" href="#doc-cot">#</a> <code>cot</code></h3>
<p><code>cot</code> returns the cotangent (1/tan) of an angle in radians.</p>
<pre><code class="lang-perl">p cot(0.7854) # ≈ 1.0 (cot 45°)
</code></pre>
</article>
<article class="doc-entry" id="doc-coulomb">
<h3><a class="doc-anchor" href="#doc-coulomb">#</a> <code>coulomb</code></h3>
<p><code>coulomb_force($q1, $q2, $r)</code> (alias <code>coulomb</code>) — Coulomb's law: F = kq₁q₂/r². Charges in Coulombs, distance in meters.</p>
<pre><code class="lang-perl">p coulomb(1e-6, 1e-6, 0.1) # ~0.9 N (two 1μC charges 10cm apart)
</code></pre>
</article>
<article class="doc-entry" id="doc-coulomb-constant">
<h3><a class="doc-anchor" href="#doc-coulomb-constant">#</a> <code>coulomb_constant</code></h3>
<p><code>coulomb_constant</code> — physics constants builtin.</p>
<pre><code class="lang-perl">my $result = coulomb_constant $x
# or in a pipeline:
@list |> map coulomb_constant |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-count-by">
<h3><a class="doc-anchor" href="#doc-count-by">#</a> <code>count_by</code></h3>
<p><code>count_by</code> — pipeline / string helpers builtin. Alias for <code>drop</code>.</p>
<pre><code class="lang-perl">my $result = count_by $x
# or in a pipeline:
@list |> map count_by |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-count-bytes">
<h3><a class="doc-anchor" href="#doc-count-bytes">#</a> <code>count_bytes</code></h3>
<p><code>count_bytes</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = count_bytes $x
# or in a pipeline:
@list |> map count_bytes |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-count-char">
<h3><a class="doc-anchor" href="#doc-count-char">#</a> <code>count_char</code></h3>
<p><code>count_char</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = count_char $x
# or in a pipeline:
@list |> map count_char |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-count-chars">
<h3><a class="doc-anchor" href="#doc-count-chars">#</a> <code>count_chars</code></h3>
<p><code>count_chars</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = count_chars $x
# or in a pipeline:
@list |> map count_chars |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-count-consonants">
<h3><a class="doc-anchor" href="#doc-count-consonants">#</a> <code>count_consonants</code></h3>
<p><code>count_consonants</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = count_consonants $x
# or in a pipeline:
@list |> map count_consonants |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-count-digits">
<h3><a class="doc-anchor" href="#doc-count-digits">#</a> <code>count_digits</code></h3>
<p><code>count_digits</code> — counters (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = count_digits $x
# or in a pipeline:
@list |> map count_digits |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-count-elem">
<h3><a class="doc-anchor" href="#doc-count-elem">#</a> <code>count_elem</code></h3>
<p><code>count_elem</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = count_elem $x
# or in a pipeline:
@list |> map count_elem |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-count-eq">
<h3><a class="doc-anchor" href="#doc-count-eq">#</a> <code>count_eq</code></h3>
<p><code>count_eq</code> — more list helpers builtin.</p>
<pre><code class="lang-perl">my $result = count_eq $x
# or in a pipeline:
@list |> map count_eq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-count-inversions">
<h3><a class="doc-anchor" href="#doc-count-inversions">#</a> <code>count_inversions</code></h3>
<p><code>count_inversions</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = count_inversions $x
# or in a pipeline:
@list |> map count_inversions |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-count-letters">
<h3><a class="doc-anchor" href="#doc-count-letters">#</a> <code>count_letters</code></h3>
<p><code>count_letters</code> — counters (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = count_letters $x
# or in a pipeline:
@list |> map count_letters |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-count-lines">
<h3><a class="doc-anchor" href="#doc-count-lines">#</a> <code>count_lines</code></h3>
<p><code>count_lines</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = count_lines $x
# or in a pipeline:
@list |> map count_lines |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-count-lower">
<h3><a class="doc-anchor" href="#doc-count-lower">#</a> <code>count_lower</code></h3>
<p><code>count_lower</code> — counters (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = count_lower $x
# or in a pipeline:
@list |> map count_lower |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-count-match">
<h3><a class="doc-anchor" href="#doc-count-match">#</a> <code>count_match</code></h3>
<p><code>count_match</code> — counters (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = count_match $x
# or in a pipeline:
@list |> map count_match |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-count-ne">
<h3><a class="doc-anchor" href="#doc-count-ne">#</a> <code>count_ne</code></h3>
<p><code>count_ne</code> — more list helpers builtin.</p>
<pre><code class="lang-perl">my $result = count_ne $x
# or in a pipeline:
@list |> map count_ne |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-count-punctuation">
<h3><a class="doc-anchor" href="#doc-count-punctuation">#</a> <code>count_punctuation</code></h3>
<p><code>count_punctuation</code> — counters (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = count_punctuation $x
# or in a pipeline:
@list |> map count_punctuation |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-count-regex-matches">
<h3><a class="doc-anchor" href="#doc-count-regex-matches">#</a> <code>count_regex_matches</code></h3>
<p><code>count_regex_matches</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = count_regex_matches $x
# or in a pipeline:
@list |> map count_regex_matches |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-count-spaces">
<h3><a class="doc-anchor" href="#doc-count-spaces">#</a> <code>count_spaces</code></h3>
<p><code>count_spaces</code> — counters (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = count_spaces $x
# or in a pipeline:
@list |> map count_spaces |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-count-substring">
<h3><a class="doc-anchor" href="#doc-count-substring">#</a> <code>count_substring</code></h3>
<p><code>count_substring</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = count_substring $x
# or in a pipeline:
@list |> map count_substring |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-count-upper">
<h3><a class="doc-anchor" href="#doc-count-upper">#</a> <code>count_upper</code></h3>
<p><code>count_upper</code> — counters (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = count_upper $x
# or in a pipeline:
@list |> map count_upper |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-count-vowels">
<h3><a class="doc-anchor" href="#doc-count-vowels">#</a> <code>count_vowels</code></h3>
<p><code>count_vowels</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = count_vowels $x
# or in a pipeline:
@list |> map count_vowels |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-count-while">
<h3><a class="doc-anchor" href="#doc-count-while">#</a> <code>count_while</code></h3>
<p><code>count_while</code> — ruby enumerable extras builtin.</p>
<pre><code class="lang-perl">my $result = count_while $x
# or in a pipeline:
@list |> map count_while |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-count-words">
<h3><a class="doc-anchor" href="#doc-count-words">#</a> <code>count_words</code></h3>
<p><code>count_words</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = count_words $x
# or in a pipeline:
@list |> map count_words |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-counter">
<h3><a class="doc-anchor" href="#doc-counter">#</a> <code>counter</code></h3>
<p><code>counter</code> — data structure helpers builtin.</p>
<pre><code class="lang-perl">my $result = counter $x
# or in a pipeline:
@list |> map counter |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-counter-most-common">
<h3><a class="doc-anchor" href="#doc-counter-most-common">#</a> <code>counter_most_common</code></h3>
<p><code>counter_most_common</code> — data structure helpers builtin.</p>
<pre><code class="lang-perl">my $result = counter_most_common $x
# or in a pipeline:
@list |> map counter_most_common |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cov">
<h3><a class="doc-anchor" href="#doc-cov">#</a> <code>cov</code></h3>
<p><code>cov</code> — extended stdlib builtin. Alias for <code>covariance</code>.</p>
<pre><code class="lang-perl">my $result = cov $x
# or in a pipeline:
@list |> map cov |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cov2cor">
<h3><a class="doc-anchor" href="#doc-cov2cor">#</a> <code>cov2cor</code></h3>
<p><code>cov2cor</code> — convert covariance matrix to correlation matrix. Like R's cov2cor().</p>
<pre><code class="lang-perl">my $cor = cov2cor(cov_mat($data))
</code></pre>
</article>
<article class="doc-entry" id="doc-cov-mat">
<h3><a class="doc-anchor" href="#doc-cov-mat">#</a> <code>cov_mat</code></h3>
<p><code>cov_matrix</code> (alias <code>cov_mat</code>) — covariance matrix from observations.</p>
<pre><code class="lang-perl">my $S = cov_mat([[1,2],[3,4],[5,6]])
</code></pre>
</article>
<article class="doc-entry" id="doc-covariance">
<h3><a class="doc-anchor" href="#doc-covariance">#</a> <code>covariance</code></h3>
<p><code>covariance</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = covariance $x
# or in a pipeline:
@list |> map covariance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cpat">
<h3><a class="doc-anchor" href="#doc-cpat">#</a> <code>cpat</code></h3>
<p><code>cpat</code> — extended stdlib builtin. Alias for <code>code_point_at</code>.</p>
<pre><code class="lang-perl">my $result = cpat $x
# or in a pipeline:
@list |> map cpat |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cpfx">
<h3><a class="doc-anchor" href="#doc-cpfx">#</a> <code>cpfx</code></h3>
<p><code>cpfx</code> — extended stdlib builtin. Alias for <code>common_prefix</code>.</p>
<pre><code class="lang-perl">my $result = cpfx $x
# or in a pipeline:
@list |> map cpfx |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cprod">
<h3><a class="doc-anchor" href="#doc-cprod">#</a> <code>cprod</code></h3>
<p><code>cprod</code> — python/ruby stdlib builtin. Alias for <code>cartesian_product</code>.</p>
<pre><code class="lang-perl">my $result = cprod $x
# or in a pipeline:
@list |> map cprod |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cprod-acc">
<h3><a class="doc-anchor" href="#doc-cprod-acc">#</a> <code>cprod_acc</code></h3>
<p><code>cprod_acc</code> — extended stdlib builtin. Alias for <code>cumprod</code>.</p>
<pre><code class="lang-perl">my $result = cprod_acc $x
# or in a pipeline:
@list |> map cprod_acc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cpsgn">
<h3><a class="doc-anchor" href="#doc-cpsgn">#</a> <code>cpsgn</code></h3>
<p><code>cpsgn</code> — extended stdlib builtin. Alias for <code>copy_sign</code>.</p>
<pre><code class="lang-perl">my $result = cpsgn $x
# or in a pipeline:
@list |> map cpsgn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cpu-count">
<h3><a class="doc-anchor" href="#doc-cpu-count">#</a> <code>cpu_count</code></h3>
<p><code>cpu_count</code> — more process / system builtin.</p>
<pre><code class="lang-perl">my $result = cpu_count $x
# or in a pipeline:
@list |> map cpu_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cpyw">
<h3><a class="doc-anchor" href="#doc-cpyw">#</a> <code>cpyw</code></h3>
<p><code>cpyw</code> — additional missing stdlib functions builtin. Alias for <code>copy_within</code>.</p>
<pre><code class="lang-perl">my $result = cpyw $x
# or in a pipeline:
@list |> map cpyw |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cr">
<h3><a class="doc-anchor" href="#doc-cr">#</a> <code>cr</code></h3>
<p><code>cr</code> — data / network builtin. Alias for <code>csv_read</code>.</p>
<pre><code class="lang-perl">my $result = cr $x
# or in a pipeline:
@list |> map cr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-critang">
<h3><a class="doc-anchor" href="#doc-critang">#</a> <code>critang</code></h3>
<p><code>critang</code> — physics formulas builtin. Alias for <code>critical_angle</code>.</p>
<pre><code class="lang-perl">my $result = critang $x
# or in a pipeline:
@list |> map critang |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-critical-angle">
<h3><a class="doc-anchor" href="#doc-critical-angle">#</a> <code>critical_angle</code></h3>
<p><code>critical_angle</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = critical_angle $x
# or in a pipeline:
@list |> map critical_angle |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cross-correlation">
<h3><a class="doc-anchor" href="#doc-cross-correlation">#</a> <code>cross_correlation</code></h3>
<p><code>cross_correlation(\@a, \@b)</code> (alias <code>xcorr</code>) — computes the cross-correlation of two signals. Measures similarity as a function of time-lag. Peak location indicates time delay between signals.</p>
<pre><code class="lang-perl">my $xcor = xcorr(\@signal1, \@signal2)
my $lag = max_index(@$xcor) # find peak lag
</code></pre>
</article>
<article class="doc-entry" id="doc-cross-entropy">
<h3><a class="doc-anchor" href="#doc-cross-entropy">#</a> <code>cross_entropy</code></h3>
<p><code>cross_entropy</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = cross_entropy $x
# or in a pipeline:
@list |> map cross_entropy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cross-product">
<h3><a class="doc-anchor" href="#doc-cross-product">#</a> <code>cross_product</code></h3>
<p><code>cross_product</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = cross_product $x
# or in a pipeline:
@list |> map cross_product |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-crossp">
<h3><a class="doc-anchor" href="#doc-crossp">#</a> <code>crossp</code></h3>
<p><code>crossp</code> — extended stdlib builtin. Alias for <code>cross_product</code>.</p>
<pre><code class="lang-perl">my $result = crossp $x
# or in a pipeline:
@list |> map crossp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-crossprod">
<h3><a class="doc-anchor" href="#doc-crossprod">#</a> <code>crossprod</code></h3>
<p><code>crossprod</code> — cross product t(M) * M (R's crossprod). Efficiently computes M^T M without explicit transpose.</p>
<pre><code class="lang-perl">my $ata = crossprod([[1,2],[3,4]]) # [[10,14],[14,20]]
</code></pre>
</article>
<article class="doc-entry" id="doc-csc">
<h3><a class="doc-anchor" href="#doc-csc">#</a> <code>csc</code></h3>
<p><code>csc</code> returns the cosecant (1/sin) of an angle in radians.</p>
<pre><code class="lang-perl">p csc(1.5708) # ≈ 1.0 (csc 90°)
</code></pre>
</article>
<article class="doc-entry" id="doc-csfx">
<h3><a class="doc-anchor" href="#doc-csfx">#</a> <code>csfx</code></h3>
<p><code>csfx</code> — extended stdlib builtin. Alias for <code>common_suffix</code>.</p>
<pre><code class="lang-perl">my $result = csfx $x
# or in a pipeline:
@list |> map csfx |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cspline">
<h3><a class="doc-anchor" href="#doc-cspline">#</a> <code>cspline</code></h3>
<p><code>cubic_spline</code> (aliases <code>cspline</code>, <code>spline</code>) performs natural cubic spline interpolation. Takes xs, ys, and a query point x.</p>
<pre><code class="lang-perl">p spline([0,1,2,3], [0,1,0,1], 1.5) # smooth interpolation
</code></pre>
</article>
<article class="doc-entry" id="doc-csum">
<h3><a class="doc-anchor" href="#doc-csum">#</a> <code>csum</code></h3>
<p><code>csum</code> — extended stdlib builtin. Alias for <code>cumsum</code>.</p>
<pre><code class="lang-perl">my $result = csum $x
# or in a pipeline:
@list |> map csum |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ctime">
<h3><a class="doc-anchor" href="#doc-ctime">#</a> <code>ctime</code></h3>
<p><code>ctime</code> — file stat / path builtin. Alias for <code>file_ctime</code>.</p>
<pre><code class="lang-perl">my $result = ctime $x
# or in a pipeline:
@list |> map ctime |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ctxt">
<h3><a class="doc-anchor" href="#doc-ctxt">#</a> <code>ctxt</code></h3>
<p><code>ctxt</code> — extended stdlib builtin. Alias for <code>center_text</code>.</p>
<pre><code class="lang-perl">my $result = ctxt $x
# or in a pipeline:
@list |> map ctxt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cube-fn">
<h3><a class="doc-anchor" href="#doc-cube-fn">#</a> <code>cube_fn</code></h3>
<p><code>cube_fn</code> — trig / math (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = cube_fn $x
# or in a pipeline:
@list |> map cube_fn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cube-root">
<h3><a class="doc-anchor" href="#doc-cube-root">#</a> <code>cube_root</code></h3>
<p><code>cube_root</code> — math functions builtin.</p>
<pre><code class="lang-perl">my $result = cube_root $x
# or in a pipeline:
@list |> map cube_root |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cubes-seq">
<h3><a class="doc-anchor" href="#doc-cubes-seq">#</a> <code>cubes_seq</code></h3>
<p><code>cubes_seq</code> — sequences builtin.</p>
<pre><code class="lang-perl">my $result = cubes_seq $x
# or in a pipeline:
@list |> map cubes_seq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cummax">
<h3><a class="doc-anchor" href="#doc-cummax">#</a> <code>cummax</code></h3>
<p><code>cummax</code> — cumulative maximum. Each element is the max of all elements up to that position.</p>
<pre><code class="lang-perl">p cummax([3,1,4,1,5,9]) # [3,3,4,4,5,9]
</code></pre>
</article>
<article class="doc-entry" id="doc-cummin">
<h3><a class="doc-anchor" href="#doc-cummin">#</a> <code>cummin</code></h3>
<p><code>cummin</code> — cumulative minimum.</p>
<pre><code class="lang-perl">p cummin([9,5,1,4,3]) # [9,5,1,1,1]
</code></pre>
</article>
<article class="doc-entry" id="doc-cumprod">
<h3><a class="doc-anchor" href="#doc-cumprod">#</a> <code>cumprod</code></h3>
<p><code>cumprod</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = cumprod $x
# or in a pipeline:
@list |> map cumprod |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cumsum">
<h3><a class="doc-anchor" href="#doc-cumsum">#</a> <code>cumsum</code></h3>
<p><code>cumsum</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = cumsum $x
# or in a pipeline:
@list |> map cumsum |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cumtrapz">
<h3><a class="doc-anchor" href="#doc-cumtrapz">#</a> <code>cumtrapz</code></h3>
<p><code>cumtrapz</code> cumulative trapezoidal integration. Returns running integral array.</p>
<pre><code class="lang-perl">my @y = (1, 2, 3, 4)
my @F = @{cumtrapz(\@y)} # [0, 1.5, 4.0, 7.5]
</code></pre>
</article>
<article class="doc-entry" id="doc-cups-to-ml">
<h3><a class="doc-anchor" href="#doc-cups-to-ml">#</a> <code>cups_to_ml</code></h3>
<p><code>cups_to_ml</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = cups_to_ml $input
</code></pre>
</article>
<article class="doc-entry" id="doc-cut">
<h3><a class="doc-anchor" href="#doc-cut">#</a> <code>cut</code></h3>
<p><code>cut</code> — bin continuous values into intervals. Returns integer bin indices. Like R's cut().</p>
<pre><code class="lang-perl">p cut([1.5, 3.2, 7.8], [0, 2, 5, 10]) # [1, 2, 3]
</code></pre>
</article>
<article class="doc-entry" id="doc-cutree">
<h3><a class="doc-anchor" href="#doc-cutree">#</a> <code>cutree</code></h3>
<p><code>cutree</code> — cut a dendrogram into k clusters. Takes merge list from hclust and k. Returns cluster assignments. Like R's cutree().</p>
<pre><code class="lang-perl">my @clusters = @{cutree(hclust(dist_mat($data)), 3)}
</code></pre>
</article>
<article class="doc-entry" id="doc-cv">
<h3><a class="doc-anchor" href="#doc-cv">#</a> <code>cv</code></h3>
<p><code>cv</code> — math / numeric (uncategorized batch) builtin. Alias for <code>coeff_of_variation</code>.</p>
<pre><code class="lang-perl">my $result = cv $x
# or in a pipeline:
@list |> map cv |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cw">
<h3><a class="doc-anchor" href="#doc-cw">#</a> <code>cw</code></h3>
<p><code>cw</code> — data / network builtin. Alias for <code>csv_write</code>.</p>
<pre><code class="lang-perl">my $result = cw $x
# or in a pipeline:
@list |> map cw |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cwd">
<h3><a class="doc-anchor" href="#doc-cwd">#</a> <code>cwd</code></h3>
<p><code>cwd</code> — more process / system builtin.</p>
<pre><code class="lang-perl">my $result = cwd $x
# or in a pipeline:
@list |> map cwd |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cyan">
<h3><a class="doc-anchor" href="#doc-cyan">#</a> <code>cyan</code></h3>
<p><code>cyan</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = cyan $x
# or in a pipeline:
@list |> map cyan |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cyan-bold">
<h3><a class="doc-anchor" href="#doc-cyan-bold">#</a> <code>cyan_bold</code></h3>
<p><code>cyan_bold</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = cyan_bold $x
# or in a pipeline:
@list |> map cyan_bold |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cyber-banner">
<h3><a class="doc-anchor" href="#doc-cyber-banner">#</a> <code>cyber_banner</code></h3>
<p><code>cyber_banner</code> (alias <code>neon_banner</code>) — large neon block-letter banner with gradient coloring and border. Args: text.</p>
<pre><code class="lang-perl">p cyber_banner("STRYKE")
p cyber_banner("HACK THE PLANET")
</code></pre>
</article>
<article class="doc-entry" id="doc-cyber-circuit">
<h3><a class="doc-anchor" href="#doc-cyber-circuit">#</a> <code>cyber_circuit</code></h3>
<p><code>cyber_circuit</code> — circuit board pattern with traces, intersections, and glowing nodes. Args: [width, height, seed].</p>
<pre><code class="lang-perl">p cyber_circuit() # 60x20 default
p cyber_circuit(80, 30, 42) # custom
</code></pre>
</article>
<article class="doc-entry" id="doc-cyber-city">
<h3><a class="doc-anchor" href="#doc-cyber-city">#</a> <code>cyber_city</code></h3>
<p><code>cyber_city</code> — procedural neon cityscape with buildings, windows, stars, and antennas. Args: [width, height, seed]. Output: ANSI-colored string for terminal.</p>
<pre><code class="lang-perl">p cyber_city() # 80x24 default
p cyber_city(120, 40, 99) # custom size and seed
</code></pre>
</article>
<article class="doc-entry" id="doc-cyber-eye">
<h3><a class="doc-anchor" href="#doc-cyber-eye">#</a> <code>cyber_eye</code></h3>
<p><code>cyber_eye</code> — cyberpunk all-seeing eye motif with layered glow. Args: [size]. Size: "small" (default) or "large".</p>
<pre><code class="lang-perl">p cyber_eye() # small eye
p cyber_eye("large") # large eye
</code></pre>
</article>
<article class="doc-entry" id="doc-cyber-glitch">
<h3><a class="doc-anchor" href="#doc-cyber-glitch">#</a> <code>cyber_glitch</code></h3>
<p><code>cyber_glitch</code> (alias <code>glitch_text</code>) — glitch-distort text with ANSI corruption, screen tears, and neon color bleeding. Args: text [, intensity 1-10].</p>
<pre><code class="lang-perl">p cyber_glitch("SYSTEM BREACH", 7)
p cyber_glitch("hello world")
</code></pre>
</article>
<article class="doc-entry" id="doc-cyber-grid">
<h3><a class="doc-anchor" href="#doc-cyber-grid">#</a> <code>cyber_grid</code></h3>
<p><code>cyber_grid</code> — retro perspective grid with vanishing point and neon glow (Tron/synthwave style). Args: [width, height].</p>
<pre><code class="lang-perl">p cyber_grid() # 80x24 default
p cyber_grid(120, 30) # wider grid
</code></pre>
</article>
<article class="doc-entry" id="doc-cyber-rain">
<h3><a class="doc-anchor" href="#doc-cyber-rain">#</a> <code>cyber_rain</code></h3>
<p><code>cyber_rain</code> (alias <code>matrix_rain</code>) — matrix-style digital rain with Japanese katakana and green phosphor glow. Args: [width, height, seed].</p>
<pre><code class="lang-perl">p cyber_rain() # 80x24 default
p cyber_rain(120, 40, 42) # custom
</code></pre>
</article>
<article class="doc-entry" id="doc-cyber-skull">
<h3><a class="doc-anchor" href="#doc-cyber-skull">#</a> <code>cyber_skull</code></h3>
<p><code>cyber_skull</code> — neon skull ASCII art with glitch effects. Args: [size]. Size: "small" (default) or "large".</p>
<pre><code class="lang-perl">p cyber_skull() # small skull
p cyber_skull("large") # large skull
</code></pre>
</article>
<article class="doc-entry" id="doc-cyc">
<h3><a class="doc-anchor" href="#doc-cyc">#</a> <code>cyc</code></h3>
<p><code>cyc</code> — algebraic match builtin. Alias for <code>cycle</code>.</p>
<pre><code class="lang-perl">my $result = cyc $x
# or in a pipeline:
@list |> map cyc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cycle">
<h3><a class="doc-anchor" href="#doc-cycle">#</a> <code>cycle</code></h3>
<p><code>cycle</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = cycle $x
# or in a pipeline:
@list |> map cycle |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cycle-n">
<h3><a class="doc-anchor" href="#doc-cycle-n">#</a> <code>cycle_n</code></h3>
<p><code>cycle_n</code> — collection (batch 2) builtin. Alias for <code>repeat_list</code>.</p>
<pre><code class="lang-perl">my $result = cycle_n $x
# or in a pipeline:
@list |> map cycle_n |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cylinder-volume">
<h3><a class="doc-anchor" href="#doc-cylinder-volume">#</a> <code>cylinder_volume</code></h3>
<p><code>cylinder_volume</code> — geometry / physics builtin.</p>
<pre><code class="lang-perl">my $result = cylinder_volume $x
# or in a pipeline:
@list |> map cylinder_volume |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-cylvol">
<h3><a class="doc-anchor" href="#doc-cylvol">#</a> <code>cylvol</code></h3>
<p><code>cylvol</code> — geometry / physics builtin. Alias for <code>cylinder_volume</code>.</p>
<pre><code class="lang-perl">my $result = cylvol $x
# or in a pipeline:
@list |> map cylvol |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-d">
<h3><a class="doc-anchor" href="#doc-d">#</a> <code>d</code></h3>
<p><code>d</code> — filesystem extensions builtin.</p>
<pre><code class="lang-perl">my $result = d $x
# or in a pipeline:
@list |> map d |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-d2comp">
<h3><a class="doc-anchor" href="#doc-d2comp">#</a> <code>d2comp</code></h3>
<p><code>d2comp</code> — misc / utility builtin. Alias for <code>degrees_to_compass</code>.</p>
<pre><code class="lang-perl">my $result = d2comp $x
# or in a pipeline:
@list |> map d2comp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-d2r">
<h3><a class="doc-anchor" href="#doc-d2r">#</a> <code>d2r</code></h3>
<p><code>d2r</code> — trivial numeric / predicate builtins builtin. Alias for <code>deg_to_rad</code>.</p>
<pre><code class="lang-perl">my $result = d2r $x
# or in a pipeline:
@list |> map d2r |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-day-of-year">
<h3><a class="doc-anchor" href="#doc-day-of-year">#</a> <code>day_of_year</code></h3>
<p><code>day_of_year</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = day_of_year $x
# or in a pipeline:
@list |> map day_of_year |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-days-in-month">
<h3><a class="doc-anchor" href="#doc-days-in-month">#</a> <code>days_in_month</code></h3>
<p><code>days_in_month</code> — date helpers builtin.</p>
<pre><code class="lang-perl">my $result = days_in_month $x
# or in a pipeline:
@list |> map days_in_month |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-days-in-month-fn">
<h3><a class="doc-anchor" href="#doc-days-in-month-fn">#</a> <code>days_in_month_fn</code></h3>
<p><code>days_in_month_fn</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = days_in_month_fn $x
# or in a pipeline:
@list |> map days_in_month_fn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-days-to-hours">
<h3><a class="doc-anchor" href="#doc-days-to-hours">#</a> <code>days_to_hours</code></h3>
<p><code>days_to_hours</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = days_to_hours $input
</code></pre>
</article>
<article class="doc-entry" id="doc-days-to-seconds">
<h3><a class="doc-anchor" href="#doc-days-to-seconds">#</a> <code>days_to_seconds</code></h3>
<p><code>days_to_seconds</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = days_to_seconds $input
</code></pre>
</article>
<article class="doc-entry" id="doc-daysinmo">
<h3><a class="doc-anchor" href="#doc-daysinmo">#</a> <code>daysinmo</code></h3>
<p><code>daysinmo</code> — extended stdlib batch 3 builtin. Alias for <code>days_in_month_fn</code>.</p>
<pre><code class="lang-perl">my $result = daysinmo $x
# or in a pipeline:
@list |> map daysinmo |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-db">
<h3><a class="doc-anchor" href="#doc-db">#</a> <code>db</code></h3>
<p><code>db</code> — physics formulas builtin. Alias for <code>decibel_ratio</code>.</p>
<pre><code class="lang-perl">my $result = db $x
# or in a pipeline:
@list |> map db |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dbinom">
<h3><a class="doc-anchor" href="#doc-dbinom">#</a> <code>dbinom</code></h3>
<p><code>dbinom</code> — binomial PMF. P(X = k) for Binom(n, p). Args: k, n, p.</p>
<pre><code class="lang-perl">p dbinom(5, 10, 0.5) # P(exactly 5 heads in 10 flips)
</code></pre>
</article>
<article class="doc-entry" id="doc-dbmclose">
<h3><a class="doc-anchor" href="#doc-dbmclose">#</a> <code>dbmclose</code></h3>
<p><code>dbmclose</code> — ipc builtin.</p>
<pre><code class="lang-perl">my $result = dbmclose $x
# or in a pipeline:
@list |> map dbmclose |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dbmopen">
<h3><a class="doc-anchor" href="#doc-dbmopen">#</a> <code>dbmopen</code></h3>
<p><code>dbmopen</code> — ipc builtin.</p>
<pre><code class="lang-perl">my $result = dbmopen $x
# or in a pipeline:
@list |> map dbmopen |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dct">
<h3><a class="doc-anchor" href="#doc-dct">#</a> <code>dct</code></h3>
<p><code>dct</code> computes the Type-II Discrete Cosine Transform of a signal. Used in JPEG, MP3, and speech processing.</p>
<pre><code class="lang-perl">my @coeffs = @{dct([1,2,3,4])}
</code></pre>
</article>
<article class="doc-entry" id="doc-ddt">
<h3><a class="doc-anchor" href="#doc-ddt">#</a> <code>ddt</code></h3>
<p><code>ddt</code> — extended stdlib builtin. Alias for <code>dedent</code>.</p>
<pre><code class="lang-perl">my $result = ddt $x
# or in a pipeline:
@list |> map ddt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-de-broglie-wavelength">
<h3><a class="doc-anchor" href="#doc-de-broglie-wavelength">#</a> <code>de_broglie_wavelength</code></h3>
<p><code>de_broglie_wavelength($mass, $velocity)</code> (alias <code>debroglie</code>) — quantum wavelength λ = h/(mv). Defaults to electron mass.</p>
<pre><code class="lang-perl">p debroglie(9.109e-31, 1e6) # ~7.3e-10 m (electron at 1 km/s)
</code></pre>
</article>
<article class="doc-entry" id="doc-debug-val">
<h3><a class="doc-anchor" href="#doc-debug-val">#</a> <code>debug_val</code></h3>
<p><code>debug_val</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = debug_val $x
# or in a pipeline:
@list |> map debug_val |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dec">
<h3><a class="doc-anchor" href="#doc-dec">#</a> <code>dec</code></h3>
<p><code>dec</code> — pipeline / string helpers builtin.</p>
<pre><code class="lang-perl">my $result = dec $x
# or in a pipeline:
@list |> map dec |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dec-each">
<h3><a class="doc-anchor" href="#doc-dec-each">#</a> <code>dec_each</code></h3>
<p><code>dec_each</code> — trivial numeric helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = dec_each $x
# or in a pipeline:
@list |> map dec_each |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-decibel-ratio">
<h3><a class="doc-anchor" href="#doc-decibel-ratio">#</a> <code>decibel_ratio</code></h3>
<p><code>decibel_ratio</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = decibel_ratio $x
# or in a pipeline:
@list |> map decibel_ratio |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dedent">
<h3><a class="doc-anchor" href="#doc-dedent">#</a> <code>dedent</code></h3>
<p><code>dedent</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = dedent $x
# or in a pipeline:
@list |> map dedent |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dedent-text">
<h3><a class="doc-anchor" href="#doc-dedent-text">#</a> <code>dedent_text</code></h3>
<p><code>dedent_text</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = dedent_text $x
# or in a pipeline:
@list |> map dedent_text |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-default-to">
<h3><a class="doc-anchor" href="#doc-default-to">#</a> <code>default_to</code></h3>
<p><code>default_to</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = default_to $x
# or in a pipeline:
@list |> map default_to |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-defaultdict">
<h3><a class="doc-anchor" href="#doc-defaultdict">#</a> <code>defaultdict</code></h3>
<p><code>defaultdict</code> — data structure helpers builtin.</p>
<pre><code class="lang-perl">my $result = defaultdict $x
# or in a pipeline:
@list |> map defaultdict |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-deficient-numbers">
<h3><a class="doc-anchor" href="#doc-deficient-numbers">#</a> <code>deficient_numbers</code></h3>
<p><code>deficient_numbers</code> — number theory / primes builtin.</p>
<pre><code class="lang-perl">my $result = deficient_numbers $x
# or in a pipeline:
@list |> map deficient_numbers |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-defined-count">
<h3><a class="doc-anchor" href="#doc-defined-count">#</a> <code>defined_count</code></h3>
<p><code>defined_count</code> — counters (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = defined_count $x
# or in a pipeline:
@list |> map defined_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-definums">
<h3><a class="doc-anchor" href="#doc-definums">#</a> <code>definums</code></h3>
<p><code>definums</code> — number theory / primes builtin. Alias for <code>deficient_numbers</code>.</p>
<pre><code class="lang-perl">my $result = definums $x
# or in a pipeline:
@list |> map definums |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-deg-to-rad">
<h3><a class="doc-anchor" href="#doc-deg-to-rad">#</a> <code>deg_to_rad</code></h3>
<p><code>deg_to_rad</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = deg_to_rad $input
</code></pre>
</article>
<article class="doc-entry" id="doc-degrees">
<h3><a class="doc-anchor" href="#doc-degrees">#</a> <code>degrees</code></h3>
<p><code>degrees</code> — trig / math (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = degrees $x
# or in a pipeline:
@list |> map degrees |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-degrees-to-compass">
<h3><a class="doc-anchor" href="#doc-degrees-to-compass">#</a> <code>degrees_to_compass</code></h3>
<p><code>degrees_to_compass</code> — misc / utility builtin.</p>
<pre><code class="lang-perl">my $result = degrees_to_compass $input
</code></pre>
</article>
<article class="doc-entry" id="doc-dela">
<h3><a class="doc-anchor" href="#doc-dela">#</a> <code>dela</code></h3>
<p><code>dela</code> — go/general functional utilities builtin. Alias for <code>delete_at</code>.</p>
<pre><code class="lang-perl">my $result = dela $x
# or in a pipeline:
@list |> map dela |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-delby">
<h3><a class="doc-anchor" href="#doc-delby">#</a> <code>delby</code></h3>
<p><code>delby</code> — additional missing stdlib functions builtin. Alias for <code>delete_by</code>.</p>
<pre><code class="lang-perl">my $result = delby $x
# or in a pipeline:
@list |> map delby |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-delete-at">
<h3><a class="doc-anchor" href="#doc-delete-at">#</a> <code>delete_at</code></h3>
<p><code>delete_at</code> — go/general functional utilities builtin.</p>
<pre><code class="lang-perl">my $result = delete_at $x
# or in a pipeline:
@list |> map delete_at |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-delete-by">
<h3><a class="doc-anchor" href="#doc-delete-by">#</a> <code>delete_by</code></h3>
<p><code>delete_by</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = delete_by $x
# or in a pipeline:
@list |> map delete_by |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-delete-first">
<h3><a class="doc-anchor" href="#doc-delete-first">#</a> <code>delete_first</code></h3>
<p><code>delete_first</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = delete_first $x
# or in a pipeline:
@list |> map delete_first |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-delfst">
<h3><a class="doc-anchor" href="#doc-delfst">#</a> <code>delfst</code></h3>
<p><code>delfst</code> — additional missing stdlib functions builtin. Alias for <code>delete_first</code>.</p>
<pre><code class="lang-perl">my $result = delfst $x
# or in a pipeline:
@list |> map delfst |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-demorse">
<h3><a class="doc-anchor" href="#doc-demorse">#</a> <code>demorse</code></h3>
<p><code>demorse</code> — encoding / phonetics builtin. Alias for <code>morse_decode</code>.</p>
<pre><code class="lang-perl">my $result = demorse $x
# or in a pipeline:
@list |> map demorse |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dense-rank">
<h3><a class="doc-anchor" href="#doc-dense-rank">#</a> <code>dense_rank</code></h3>
<p><code>dense_rank</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = dense_rank $x
# or in a pipeline:
@list |> map dense_rank |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-density">
<h3><a class="doc-anchor" href="#doc-density">#</a> <code>density</code></h3>
<p><code>density</code> — kernel density estimation with Gaussian kernel and Silverman bandwidth. Returns [[x_grid], [density_values]]. Like R's density().</p>
<pre><code class="lang-perl">my ($x, $y) = @{density([1,2,2,3,3,3,4,4,5])}
# $x is grid of 512 points, $y is estimated density
</code></pre>
</article>
<article class="doc-entry" id="doc-depdbl">
<h3><a class="doc-anchor" href="#doc-depdbl">#</a> <code>depdbl</code></h3>
<p><code>depdbl</code> — math / numeric (uncategorized batch) builtin. Alias for <code>depreciation_double</code>.</p>
<pre><code class="lang-perl">my $result = depdbl $x
# or in a pipeline:
@list |> map depdbl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-deplin">
<h3><a class="doc-anchor" href="#doc-deplin">#</a> <code>deplin</code></h3>
<p><code>deplin</code> — math / numeric (uncategorized batch) builtin. Alias for <code>depreciation_linear</code>.</p>
<pre><code class="lang-perl">my $result = deplin $x
# or in a pipeline:
@list |> map deplin |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-depreciation-double">
<h3><a class="doc-anchor" href="#doc-depreciation-double">#</a> <code>depreciation_double</code></h3>
<p><code>depreciation_double</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = depreciation_double $x
# or in a pipeline:
@list |> map depreciation_double |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-depreciation-linear">
<h3><a class="doc-anchor" href="#doc-depreciation-linear">#</a> <code>depreciation_linear</code></h3>
<p><code>depreciation_linear</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = depreciation_linear $x
# or in a pipeline:
@list |> map depreciation_linear |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-derangements">
<h3><a class="doc-anchor" href="#doc-derangements">#</a> <code>derangements</code></h3>
<p><code>derangements</code> counts the number of derangements (subfactorial !n) — permutations with no fixed points.</p>
<pre><code class="lang-perl">p derangements(4) # 9
p derangements(5) # 44
</code></pre>
</article>
<article class="doc-entry" id="doc-deroman">
<h3><a class="doc-anchor" href="#doc-deroman">#</a> <code>deroman</code></h3>
<p><code>deroman</code> — roman numerals builtin. Alias for <code>roman_to_int</code>.</p>
<pre><code class="lang-perl">my $result = deroman $x
# or in a pipeline:
@list |> map deroman |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-describe">
<h3><a class="doc-anchor" href="#doc-describe">#</a> <code>describe</code></h3>
<p><code>describe(@data)</code> — returns a hashref with comprehensive descriptive statistics: count, mean, std, min, 25%, 50%, 75%, max. Similar to pandas DataFrame.describe().</p>
<pre><code class="lang-perl">my $stats = describe(1..100)
p $stats->{mean} # 50.5
p $stats->{std} # ~29.0
p $stats->{"50%"} # median
</code></pre>
</article>
<article class="doc-entry" id="doc-det">
<h3><a class="doc-anchor" href="#doc-det">#</a> <code>det</code></h3>
<p><code>matrix_det_general</code> (aliases <code>mdetg</code>, <code>det</code>) computes the determinant of any NxN matrix via LU decomposition.</p>
<pre><code class="lang-perl">p det([[1,2,3],[4,5,6],[7,8,0]]) # 27
</code></pre>
</article>
<article class="doc-entry" id="doc-detect">
<h3><a class="doc-anchor" href="#doc-detect">#</a> <code>detect</code></h3>
<p><code>detect</code> — functional / iterator builtin.</p>
<pre><code class="lang-perl">my $result = detect $x
# or in a pipeline:
@list |> map detect |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dew-point">
<h3><a class="doc-anchor" href="#doc-dew-point">#</a> <code>dew_point</code></h3>
<p><code>dew_point</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = dew_point $x
# or in a pipeline:
@list |> map dew_point |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-df">
<h3><a class="doc-anchor" href="#doc-df">#</a> <code>df</code></h3>
<p><code>df</code> — data / network builtin. Alias for <code>dataframe</code>.</p>
<pre><code class="lang-perl">my $result = df $x
# or in a pipeline:
@list |> map df |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dfact">
<h3><a class="doc-anchor" href="#doc-dfact">#</a> <code>dfact</code></h3>
<p><code>dfact</code> — math formulas builtin. Alias for <code>double_factorial</code>.</p>
<pre><code class="lang-perl">my $result = dfact $x
# or in a pipeline:
@list |> map dfact |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dfs">
<h3><a class="doc-anchor" href="#doc-dfs">#</a> <code>dfs</code></h3>
<p><code>dfs</code> — extended stdlib builtin. Alias for <code>dfs_traverse</code>.</p>
<pre><code class="lang-perl">my $result = dfs $x
# or in a pipeline:
@list |> map dfs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dfs-traverse">
<h3><a class="doc-anchor" href="#doc-dfs-traverse">#</a> <code>dfs_traverse</code></h3>
<p><code>dfs_traverse</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = dfs_traverse $x
# or in a pipeline:
@list |> map dfs_traverse |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dft">
<h3><a class="doc-anchor" href="#doc-dft">#</a> <code>dft</code></h3>
<p><code>dft(\@signal)</code> — computes the Discrete Fourier Transform. Returns arrayref of complex numbers as [re, im] pairs. O(n²) reference implementation; for large n, use FFT libraries.</p>
<pre><code class="lang-perl">my @signal = map { sin(2 * 3.14159 * $_ / 64) } 0..63
my $spectrum = dft(\@signal)
</code></pre>
</article>
<article class="doc-entry" id="doc-dgeom">
<h3><a class="doc-anchor" href="#doc-dgeom">#</a> <code>dgeom</code></h3>
<p><code>dgeom</code> — geometric PMF P(X=k). Args: k, prob.</p>
<pre><code class="lang-perl">p dgeom(3, 0.5) # P(first success on 4th trial)
</code></pre>
</article>
<article class="doc-entry" id="doc-dhyper">
<h3><a class="doc-anchor" href="#doc-dhyper">#</a> <code>dhyper</code></h3>
<p><code>dhyper</code> — hypergeometric PMF. Args: k, m (white), n (black), nn (draws).</p>
<pre><code class="lang-perl">p dhyper(2, 5, 5, 3) # P(2 white balls in 3 draws from 5W+5B)
</code></pre>
</article>
<article class="doc-entry" id="doc-diag">
<h3><a class="doc-anchor" href="#doc-diag">#</a> <code>diag</code></h3>
<p><code>diag</code> — extended stdlib builtin. Alias for <code>diagonal</code>.</p>
<pre><code class="lang-perl">my $result = diag $x
# or in a pipeline:
@list |> map diag |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-diagonal">
<h3><a class="doc-anchor" href="#doc-diagonal">#</a> <code>diagonal</code></h3>
<p><code>diagonal</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = diagonal $x
# or in a pipeline:
@list |> map diagonal |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dice-coefficient">
<h3><a class="doc-anchor" href="#doc-dice-coefficient">#</a> <code>dice_coefficient</code></h3>
<p><code>dice_coefficient</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = dice_coefficient $x
# or in a pipeline:
@list |> map dice_coefficient |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dice-roll">
<h3><a class="doc-anchor" href="#doc-dice-roll">#</a> <code>dice_roll</code></h3>
<p><code>dice_roll</code> — random builtin.</p>
<pre><code class="lang-perl">my $result = dice_roll $x
# or in a pipeline:
@list |> map dice_roll |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dicecoef">
<h3><a class="doc-anchor" href="#doc-dicecoef">#</a> <code>dicecoef</code></h3>
<p><code>dicecoef</code> — extended stdlib batch 3 builtin. Alias for <code>dice_coefficient</code>.</p>
<pre><code class="lang-perl">my $result = dicecoef $x
# or in a pipeline:
@list |> map dicecoef |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-die-if">
<h3><a class="doc-anchor" href="#doc-die-if">#</a> <code>die_if</code></h3>
<p><code>die_if</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = die_if $x
# or in a pipeline:
@list |> map die_if |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-die-unless">
<h3><a class="doc-anchor" href="#doc-die-unless">#</a> <code>die_unless</code></h3>
<p><code>die_unless</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = die_unless $x
# or in a pipeline:
@list |> map die_unless |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-diff">
<h3><a class="doc-anchor" href="#doc-diff">#</a> <code>diff</code></h3>
<p><code>diff</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = diff $x
# or in a pipeline:
@list |> map diff |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-diff-array">
<h3><a class="doc-anchor" href="#doc-diff-array">#</a> <code>diff_array</code></h3>
<p><code>numerical_diff</code> (aliases <code>numdiff</code>, <code>diff_array</code>) computes the numerical first derivative via central differences. Returns an array.</p>
<pre><code class="lang-perl">my @y = map { $_ ** 2 } 0..10
my @dy = @{numdiff(\@y)} # ≈ [0, 2, 4, 6, ...]
</code></pre>
</article>
<article class="doc-entry" id="doc-diff-days">
<h3><a class="doc-anchor" href="#doc-diff-days">#</a> <code>diff_days</code></h3>
<p><code>diff_days</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = diff_days $x
# or in a pipeline:
@list |> map diff_days |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-diff-hours">
<h3><a class="doc-anchor" href="#doc-diff-hours">#</a> <code>diff_hours</code></h3>
<p><code>diff_hours</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = diff_hours $x
# or in a pipeline:
@list |> map diff_hours |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-diff-lag">
<h3><a class="doc-anchor" href="#doc-diff-lag">#</a> <code>diff_lag</code></h3>
<p><code>diff_lag</code> (alias <code>diff_ts</code>) — lagged differences. Args: vec [, lag, differences]. Like R's diff().</p>
<pre><code class="lang-perl">p diff_lag([1,3,6,10]) # [2,3,4] (lag=1)
p diff_lag([1,3,6,10], 2) # [5,7] (lag=2)
p diff_lag([1,3,6,10], 1, 2) # [1,1] (second differences)
</code></pre>
</article>
<article class="doc-entry" id="doc-diffd">
<h3><a class="doc-anchor" href="#doc-diffd">#</a> <code>diffd</code></h3>
<p><code>diffd</code> — extended stdlib builtin. Alias for <code>diff_days</code>.</p>
<pre><code class="lang-perl">my $result = diffd $x
# or in a pipeline:
@list |> map diffd |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-diffh">
<h3><a class="doc-anchor" href="#doc-diffh">#</a> <code>diffh</code></h3>
<p><code>diffh</code> — extended stdlib builtin. Alias for <code>diff_hours</code>.</p>
<pre><code class="lang-perl">my $result = diffh $x
# or in a pipeline:
@list |> map diffh |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dig">
<h3><a class="doc-anchor" href="#doc-dig">#</a> <code>dig</code></h3>
<p><code>dig</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = dig $x
# or in a pipeline:
@list |> map dig |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-digital-root">
<h3><a class="doc-anchor" href="#doc-digital-root">#</a> <code>digital_root</code></h3>
<p><code>digital_root</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = digital_root $x
# or in a pipeline:
@list |> map digital_root |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-digits-of">
<h3><a class="doc-anchor" href="#doc-digits-of">#</a> <code>digits_of</code></h3>
<p><code>digits_of</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = digits_of $x
# or in a pipeline:
@list |> map digits_of |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-digroot">
<h3><a class="doc-anchor" href="#doc-digroot">#</a> <code>digroot</code></h3>
<p><code>digroot</code> — extended stdlib batch 3 builtin. Alias for <code>digital_root</code>.</p>
<pre><code class="lang-perl">my $result = digroot $x
# or in a pipeline:
@list |> map digroot |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dijkstra">
<h3><a class="doc-anchor" href="#doc-dijkstra">#</a> <code>dijkstra</code></h3>
<p><code>dijkstra</code> (alias <code>shortest_path</code>) computes shortest paths from a source node. Graph is a hash of {node => [[neighbor, weight], ...]}. Returns {node => distance}.</p>
<pre><code class="lang-perl">my $g = {A => [["B",1],["C",4]], B => [["C",2]], C => []}
my $d = dijkstra($g, "A") # {A=>0, B=>1, C=>3}
</code></pre>
</article>
<article class="doc-entry" id="doc-dim">
<h3><a class="doc-anchor" href="#doc-dim">#</a> <code>dim</code></h3>
<p><code>dim</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = dim $x
# or in a pipeline:
@list |> map dim |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-diopter">
<h3><a class="doc-anchor" href="#doc-diopter">#</a> <code>diopter</code></h3>
<p><code>diopter</code> — physics formulas builtin. Alias for <code>lens_power</code>.</p>
<pre><code class="lang-perl">my $result = diopter $x
# or in a pipeline:
@list |> map diopter |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dirs">
<h3><a class="doc-anchor" href="#doc-dirs">#</a> <code>dirs</code></h3>
<p><code>dirs</code> — filesystem extensions builtin.</p>
<pre><code class="lang-perl">my $result = dirs $x
# or in a pipeline:
@list |> map dirs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-discount">
<h3><a class="doc-anchor" href="#doc-discount">#</a> <code>discount</code></h3>
<p><code>discount</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = discount $x
# or in a pipeline:
@list |> map discount |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-discount-amount">
<h3><a class="doc-anchor" href="#doc-discount-amount">#</a> <code>discount_amount</code></h3>
<p><code>discount_amount</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = discount_amount $x
# or in a pipeline:
@list |> map discount_amount |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-discounted-payback">
<h3><a class="doc-anchor" href="#doc-discounted-payback">#</a> <code>discounted_payback</code></h3>
<p><code>discounted_payback($initial, $rate, @cashflows)</code> — computes payback period using discounted cash flows. Accounts for time value of money.</p>
<pre><code class="lang-perl">p discounted_payback(1000, 0.1, 400, 400, 400, 400)
</code></pre>
</article>
<article class="doc-entry" id="doc-disk-avail">
<h3><a class="doc-anchor" href="#doc-disk-avail">#</a> <code>disk_avail</code></h3>
<p><code>disk_avail PATH</code> — available disk space in bytes for non-root users. Uses <code>f_bavail</code> from <code>statvfs</code>, which excludes blocks reserved for the superuser.</p>
<pre><code class="lang-perl">p format_bytes(disk_avail) # 76.3 GiB
gauge(1 - disk_avail / disk_total) |> p # usage gauge
</code></pre>
</article>
<article class="doc-entry" id="doc-disk-free">
<h3><a class="doc-anchor" href="#doc-disk-free">#</a> <code>disk_free</code></h3>
<p><code>disk_free PATH</code> — free disk space in bytes (superuser view). Uses <code>f_bfree</code> from <code>statvfs</code>.</p>
<pre><code class="lang-perl">p format_bytes(disk_free) # 76.3 GiB
p format_bytes(disk_free("/tmp"))
</code></pre>
</article>
<article class="doc-entry" id="doc-disk-total">
<h3><a class="doc-anchor" href="#doc-disk-total">#</a> <code>disk_total</code></h3>
<p><code>disk_total PATH</code> — total disk space in bytes for the filesystem containing PATH (default <code>/</code>). Uses <code>statvfs</code> on unix. Returns <code>undef</code> on unsupported platforms.</p>
<pre><code class="lang-perl">p format_bytes(disk_total) # 1.8 TiB
p format_bytes(disk_total("/home")) # specific mount
</code></pre>
</article>
<article class="doc-entry" id="doc-disk-used">
<h3><a class="doc-anchor" href="#doc-disk-used">#</a> <code>disk_used</code></h3>
<p><code>disk_used PATH</code> — used disk space in bytes (total - free).</p>
<pre><code class="lang-perl">p format_bytes(disk_used) # 1.7 TiB
my $pct = int(disk_used / disk_total * 100)
p "$pct% disk used"
</code></pre>
</article>
<article class="doc-entry" id="doc-dissoc">
<h3><a class="doc-anchor" href="#doc-dissoc">#</a> <code>dissoc</code></h3>
<p><code>dissoc</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = dissoc $x
# or in a pipeline:
@list |> map dissoc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dist">
<h3><a class="doc-anchor" href="#doc-dist">#</a> <code>dist</code></h3>
<p><code>dist</code> — extended stdlib builtin. Alias for <code>distance</code>.</p>
<pre><code class="lang-perl">my $result = dist $x
# or in a pipeline:
@list |> map dist |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dist-mat">
<h3><a class="doc-anchor" href="#doc-dist-mat">#</a> <code>dist_mat</code></h3>
<p><code>dist_matrix</code> (alias <code>dist_mat</code>) — pairwise distance matrix. Supports 'euclidean' (default), 'manhattan', 'maximum'. Like R's dist().</p>
<pre><code class="lang-perl">my $D = dist_mat([[0,0],[1,0],[0,1]]) # 3x3 distance matrix
my $D2 = dist_mat([[0,0],[1,1]], "manhattan") # Manhattan
</code></pre>
</article>
<article class="doc-entry" id="doc-distance">
<h3><a class="doc-anchor" href="#doc-distance">#</a> <code>distance</code></h3>
<p><code>distance</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = distance $x
# or in a pipeline:
@list |> map distance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-distb">
<h3><a class="doc-anchor" href="#doc-distb">#</a> <code>distb</code></h3>
<p><code>distb</code> — additional missing stdlib functions builtin. Alias for <code>distinct_by</code>.</p>
<pre><code class="lang-perl">my $result = distb $x
# or in a pipeline:
@list |> map distb |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-distinct-by">
<h3><a class="doc-anchor" href="#doc-distinct-by">#</a> <code>distinct_by</code></h3>
<p><code>distinct_by</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = distinct_by $x
# or in a pipeline:
@list |> map distinct_by |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-distinct-count">
<h3><a class="doc-anchor" href="#doc-distinct-count">#</a> <code>distinct_count</code></h3>
<p><code>distinct_count</code> — collection (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = distinct_count $x
# or in a pipeline:
@list |> map distinct_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-divisors">
<h3><a class="doc-anchor" href="#doc-divisors">#</a> <code>divisors</code></h3>
<p><code>divisors</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = divisors $x
# or in a pipeline:
@list |> map divisors |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-divmod">
<h3><a class="doc-anchor" href="#doc-divmod">#</a> <code>divmod</code></h3>
<p><code>divmod</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = divmod $x
# or in a pipeline:
@list |> map divmod |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-divs">
<h3><a class="doc-anchor" href="#doc-divs">#</a> <code>divs</code></h3>
<p><code>divs</code> — math / numeric (uncategorized batch) builtin. Alias for <code>divisors</code>.</p>
<pre><code class="lang-perl">my $result = divs $x
# or in a pipeline:
@list |> map divs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-djb2">
<h3><a class="doc-anchor" href="#doc-djb2">#</a> <code>djb2</code></h3>
<p><code>djb2</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = djb2 $x
# or in a pipeline:
@list |> map djb2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dm">
<h3><a class="doc-anchor" href="#doc-dm">#</a> <code>dm</code></h3>
<p><code>dm</code> — python/ruby stdlib builtin. Alias for <code>divmod</code>.</p>
<pre><code class="lang-perl">my $result = dm $x
# or in a pipeline:
@list |> map dm |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dmetph">
<h3><a class="doc-anchor" href="#doc-dmetph">#</a> <code>dmetph</code></h3>
<p><code>dmetph</code> — encoding / phonetics builtin. Alias for <code>double_metaphone</code>.</p>
<pre><code class="lang-perl">my $result = dmetph $x
# or in a pipeline:
@list |> map dmetph |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dnbinom">
<h3><a class="doc-anchor" href="#doc-dnbinom">#</a> <code>dnbinom</code></h3>
<p><code>dnbinom</code> — negative binomial PMF. Args: k, size, prob.</p>
<pre><code class="lang-perl">p dnbinom(3, 5, 0.5) # P(3 failures before 5 successes)
</code></pre>
</article>
<article class="doc-entry" id="doc-do-call">
<h3><a class="doc-anchor" href="#doc-do-call">#</a> <code>do_call</code></h3>
<p><code>do_call</code> — call a function with args from a list. Like R's do.call().</p>
<pre><code class="lang-perl">my $result = docall(fn { $_[0] + $_[1] }, [3, 4]) # 7
</code></pre>
</article>
<article class="doc-entry" id="doc-doppler">
<h3><a class="doc-anchor" href="#doc-doppler">#</a> <code>doppler</code></h3>
<p><code>doppler_frequency($source_freq, $source_vel, $observer_vel)</code> (alias <code>doppler</code>) — observed frequency with Doppler effect. Uses speed of sound (343 m/s).</p>
<pre><code class="lang-perl">p doppler(440, -30, 0) # ~482 Hz (ambulance approaching at 30 m/s)
p doppler(440, 30, 0) # ~405 Hz (ambulance receding)
</code></pre>
</article>
<article class="doc-entry" id="doc-dot-case">
<h3><a class="doc-anchor" href="#doc-dot-case">#</a> <code>dot_case</code></h3>
<p><code>dot_case</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = dot_case $x
# or in a pipeline:
@list |> map dot_case |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dot-product">
<h3><a class="doc-anchor" href="#doc-dot-product">#</a> <code>dot_product</code></h3>
<p><code>dot_product</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = dot_product $x
# or in a pipeline:
@list |> map dot_product |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dotp">
<h3><a class="doc-anchor" href="#doc-dotp">#</a> <code>dotp</code></h3>
<p><code>dotp</code> — extended stdlib builtin. Alias for <code>dot_product</code>.</p>
<pre><code class="lang-perl">my $result = dotp $x
# or in a pipeline:
@list |> map dotp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-double">
<h3><a class="doc-anchor" href="#doc-double">#</a> <code>double</code></h3>
<p><code>double</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = double $x
# or in a pipeline:
@list |> map double |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-double-each">
<h3><a class="doc-anchor" href="#doc-double-each">#</a> <code>double_each</code></h3>
<p><code>double_each</code> — trivial numeric helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = double_each $x
# or in a pipeline:
@list |> map double_each |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-double-factorial">
<h3><a class="doc-anchor" href="#doc-double-factorial">#</a> <code>double_factorial</code></h3>
<p><code>double_factorial</code> — math formulas builtin.</p>
<pre><code class="lang-perl">my $result = double_factorial $x
# or in a pipeline:
@list |> map double_factorial |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-double-metaphone">
<h3><a class="doc-anchor" href="#doc-double-metaphone">#</a> <code>double_metaphone</code></h3>
<p><code>double_metaphone</code> — encoding / phonetics builtin.</p>
<pre><code class="lang-perl">my $result = double_metaphone $x
# or in a pipeline:
@list |> map double_metaphone |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-downcase-each">
<h3><a class="doc-anchor" href="#doc-downcase-each">#</a> <code>downcase_each</code></h3>
<p><code>downcase_each</code> — trivial numeric helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = downcase_each $x
# or in a pipeline:
@list |> map downcase_each |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-downsample">
<h3><a class="doc-anchor" href="#doc-downsample">#</a> <code>downsample</code></h3>
<p><code>downsample(\@signal, $factor)</code> (alias <code>decimate</code>) — reduces sample rate by keeping every nth sample. Apply anti-aliasing filter first to avoid aliasing.</p>
<pre><code class="lang-perl">my $decimated = decimate(\@signal, 4) # keep every 4th sample
</code></pre>
</article>
<article class="doc-entry" id="doc-downto">
<h3><a class="doc-anchor" href="#doc-downto">#</a> <code>downto</code></h3>
<p><code>downto</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = downto $x
# or in a pipeline:
@list |> map downto |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-doy">
<h3><a class="doc-anchor" href="#doc-doy">#</a> <code>doy</code></h3>
<p><code>doy</code> — extended stdlib batch 3 builtin. Alias for <code>day_of_year</code>.</p>
<pre><code class="lang-perl">my $result = doy $x
# or in a pipeline:
@list |> map doy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dpayback">
<h3><a class="doc-anchor" href="#doc-dpayback">#</a> <code>dpayback</code></h3>
<p><code>dpayback</code> — finance (extended) builtin. Alias for <code>discounted_payback</code>.</p>
<pre><code class="lang-perl">my $result = dpayback $x
# or in a pipeline:
@list |> map dpayback |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dr">
<h3><a class="doc-anchor" href="#doc-dr">#</a> <code>dr</code></h3>
<p><code>dr</code> — filesystem extensions builtin.</p>
<pre><code class="lang-perl">my $result = dr $x
# or in a pipeline:
@list |> map dr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-drag-force">
<h3><a class="doc-anchor" href="#doc-drag-force">#</a> <code>drag_force</code></h3>
<p><code>drag_force</code> (alias <code>fdrag</code>) computes aerodynamic drag: F = 0.5·Cd·ρ·A·v². Args: drag_coeff, air_density, area, velocity.</p>
<pre><code class="lang-perl">p fdrag(0.47, 1.225, 0.01, 30) # drag on a ball at 30 m/s
</code></pre>
</article>
<article class="doc-entry" id="doc-drnk">
<h3><a class="doc-anchor" href="#doc-drnk">#</a> <code>drnk</code></h3>
<p><code>drnk</code> — extended stdlib builtin. Alias for <code>dense_rank</code>.</p>
<pre><code class="lang-perl">my $result = drnk $x
# or in a pipeline:
@list |> map drnk |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-drop-every">
<h3><a class="doc-anchor" href="#doc-drop-every">#</a> <code>drop_every</code></h3>
<p><code>drop_every</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = drop_every $x
# or in a pipeline:
@list |> map drop_every |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-drop-last">
<h3><a class="doc-anchor" href="#doc-drop-last">#</a> <code>drop_last</code></h3>
<p><code>drop_last</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = drop_last $x
# or in a pipeline:
@list |> map drop_last |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-drop-n">
<h3><a class="doc-anchor" href="#doc-drop-n">#</a> <code>drop_n</code></h3>
<p><code>drop_n</code> — collection helpers (trivial) builtin.</p>
<pre><code class="lang-perl">my $result = drop_n $x
# or in a pipeline:
@list |> map drop_n |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dsamp">
<h3><a class="doc-anchor" href="#doc-dsamp">#</a> <code>dsamp</code></h3>
<p><code>dsamp</code> — dsp / signal (extended) builtin. Alias for <code>downsample</code>.</p>
<pre><code class="lang-perl">my $result = dsamp $x
# or in a pipeline:
@list |> map dsamp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dte">
<h3><a class="doc-anchor" href="#doc-dte">#</a> <code>dte</code></h3>
<p><code>dte</code> — date / time builtin. Alias for <code>datetime_from_epoch</code>.</p>
<pre><code class="lang-perl">my $result = dte $x
# or in a pipeline:
@list |> map dte |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dtf">
<h3><a class="doc-anchor" href="#doc-dtf">#</a> <code>dtf</code></h3>
<p><code>dtf</code> — date / time builtin. Alias for <code>datetime_strftime</code>.</p>
<pre><code class="lang-perl">my $result = dtf $x
# or in a pipeline:
@list |> map dtf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dump">
<h3><a class="doc-anchor" href="#doc-dump">#</a> <code>dump</code></h3>
<p><code>dump</code> — process / system builtin.</p>
<pre><code class="lang-perl">my $result = dump $x
# or in a pipeline:
@list |> map dump |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-dunif">
<h3><a class="doc-anchor" href="#doc-dunif">#</a> <code>dunif</code></h3>
<p><code>dunif</code> — uniform PDF. Args: x, a, b.</p>
<pre><code class="lang-perl">p dunif(0.5, 0, 1) # 1.0
</code></pre>
</article>
<article class="doc-entry" id="doc-duped">
<h3><a class="doc-anchor" href="#doc-duped">#</a> <code>duped</code></h3>
<p><code>duplicated</code> — boolean array: 1 if element appeared earlier in the vector, 0 otherwise. Like R's duplicated().</p>
<pre><code class="lang-perl">p duplicated([1,2,3,2,1]) # [0,0,0,1,1]
</code></pre>
</article>
<article class="doc-entry" id="doc-duplicate-count">
<h3><a class="doc-anchor" href="#doc-duplicate-count">#</a> <code>duplicate_count</code></h3>
<p><code>duplicate_count</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = duplicate_count $x
# or in a pipeline:
@list |> map duplicate_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-each-cons">
<h3><a class="doc-anchor" href="#doc-each-cons">#</a> <code>each_cons</code></h3>
<p><code>each_cons</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = each_cons $x
# or in a pipeline:
@list |> map each_cons |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-each-slice">
<h3><a class="doc-anchor" href="#doc-each-slice">#</a> <code>each_slice</code></h3>
<p><code>each_slice</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = each_slice $x
# or in a pipeline:
@list |> map each_slice |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-each-with-index">
<h3><a class="doc-anchor" href="#doc-each-with-index">#</a> <code>each_with_index</code></h3>
<p><code>each_with_index</code> — functional / iterator builtin.</p>
<pre><code class="lang-perl">my $result = each_with_index $x
# or in a pipeline:
@list |> map each_with_index |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-each-with-object">
<h3><a class="doc-anchor" href="#doc-each-with-object">#</a> <code>each_with_object</code></h3>
<p><code>each_with_object</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = each_with_object $x
# or in a pipeline:
@list |> map each_with_object |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-earth-mass">
<h3><a class="doc-anchor" href="#doc-earth-mass">#</a> <code>earth_mass</code></h3>
<p><code>earth_mass</code> (alias <code>mearth</code>) — M⊕ ≈ 5.972×10²⁴ kg. Mass of Earth.</p>
<pre><code class="lang-perl">p mearth # 5.972167867e24 kg
</code></pre>
</article>
<article class="doc-entry" id="doc-earth-radius">
<h3><a class="doc-anchor" href="#doc-earth-radius">#</a> <code>earth_radius</code></h3>
<p><code>earth_radius</code> — physics constants builtin.</p>
<pre><code class="lang-perl">my $result = earth_radius $x
# or in a pipeline:
@list |> map earth_radius |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ecdf">
<h3><a class="doc-anchor" href="#doc-ecdf">#</a> <code>ecdf</code></h3>
<p><code>ecdf</code> — empirical CDF: proportion of data ≤ x. Like R's ecdf().</p>
<pre><code class="lang-perl">p ecdf([1,2,3,4,5], 3) # 0.6 (3 of 5 values ≤ 3)
</code></pre>
</article>
<article class="doc-entry" id="doc-echarge">
<h3><a class="doc-anchor" href="#doc-echarge">#</a> <code>echarge</code></h3>
<p><code>echarge</code> — constants builtin. Alias for <code>elementary_charge</code>.</p>
<pre><code class="lang-perl">my $result = echarge $x
# or in a pipeline:
@list |> map echarge |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-econs">
<h3><a class="doc-anchor" href="#doc-econs">#</a> <code>econs</code></h3>
<p><code>econs</code> — python/ruby stdlib builtin. Alias for <code>each_cons</code>.</p>
<pre><code class="lang-perl">my $result = econs $x
# or in a pipeline:
@list |> map econs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-efield">
<h3><a class="doc-anchor" href="#doc-efield">#</a> <code>efield</code></h3>
<p><code>efield</code> — physics formulas builtin. Alias for <code>electric_field</code>.</p>
<pre><code class="lang-perl">my $result = efield $x
# or in a pipeline:
@list |> map efield |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-eig">
<h3><a class="doc-anchor" href="#doc-eig">#</a> <code>eig</code></h3>
<p><code>matrix_eigenvalues</code> (aliases <code>meig</code>, <code>eig</code>) computes eigenvalues of a square matrix via QR iteration. Returns an array of eigenvalues.</p>
<pre><code class="lang-perl">my @eigs = @{eig([[2,1],[1,2]])} # [3, 1]
</code></pre>
</article>
<article class="doc-entry" id="doc-either">
<h3><a class="doc-anchor" href="#doc-either">#</a> <code>either</code></h3>
<p><code>either</code> — boolean combinators builtin.</p>
<pre><code class="lang-perl">my $result = either $x
# or in a pipeline:
@list |> map either |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-electric-field">
<h3><a class="doc-anchor" href="#doc-electric-field">#</a> <code>electric_field</code></h3>
<p><code>electric_field</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = electric_field $x
# or in a pipeline:
@list |> map electric_field |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-electron-mass">
<h3><a class="doc-anchor" href="#doc-electron-mass">#</a> <code>electron_mass</code></h3>
<p><code>electron_mass</code> — constants builtin.</p>
<pre><code class="lang-perl">my $result = electron_mass $x
# or in a pipeline:
@list |> map electron_mass |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-elem-at">
<h3><a class="doc-anchor" href="#doc-elem-at">#</a> <code>elem_at</code></h3>
<p><code>elem_at</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = elem_at $x
# or in a pipeline:
@list |> map elem_at |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-elem-index">
<h3><a class="doc-anchor" href="#doc-elem-index">#</a> <code>elem_index</code></h3>
<p><code>elem_index</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = elem_index $x
# or in a pipeline:
@list |> map elem_index |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-elem-indices">
<h3><a class="doc-anchor" href="#doc-elem-indices">#</a> <code>elem_indices</code></h3>
<p><code>elem_indices</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = elem_indices $x
# or in a pipeline:
@list |> map elem_indices |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-elem-of">
<h3><a class="doc-anchor" href="#doc-elem-of">#</a> <code>elem_of</code></h3>
<p><code>elem_of</code> — haskell list functions builtin.</p>
<pre><code class="lang-perl">my $result = elem_of $x
# or in a pipeline:
@list |> map elem_of |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-elementary-charge">
<h3><a class="doc-anchor" href="#doc-elementary-charge">#</a> <code>elementary_charge</code></h3>
<p><code>elementary_charge</code> — constants builtin.</p>
<pre><code class="lang-perl">my $result = elementary_charge $x
# or in a pipeline:
@list |> map elementary_charge |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-elidx">
<h3><a class="doc-anchor" href="#doc-elidx">#</a> <code>elidx</code></h3>
<p><code>elidx</code> — additional missing stdlib functions builtin. Alias for <code>elem_index</code>.</p>
<pre><code class="lang-perl">my $result = elidx $x
# or in a pipeline:
@list |> map elidx |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-elidxs">
<h3><a class="doc-anchor" href="#doc-elidxs">#</a> <code>elidxs</code></h3>
<p><code>elidxs</code> — additional missing stdlib functions builtin. Alias for <code>elem_indices</code>.</p>
<pre><code class="lang-perl">my $result = elidxs $x
# or in a pipeline:
@list |> map elidxs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ellipperim">
<h3><a class="doc-anchor" href="#doc-ellipperim">#</a> <code>ellipperim</code></h3>
<p><code>ellipperim</code> — geometry (extended) builtin. Alias for <code>ellipse_perimeter</code>.</p>
<pre><code class="lang-perl">my $result = ellipperim $x
# or in a pipeline:
@list |> map ellipperim |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ellipse-perimeter">
<h3><a class="doc-anchor" href="#doc-ellipse-perimeter">#</a> <code>ellipse_perimeter</code></h3>
<p><code>ellipse_perimeter($a, $b)</code> (alias <code>ellper</code>) — approximates the perimeter of an ellipse with semi-axes a and b. Uses Ramanujan's approximation.</p>
<pre><code class="lang-perl">p ellper(5, 3) # ~25.5
p ellper(10, 10) # ~62.8 (circle)
</code></pre>
</article>
<article class="doc-entry" id="doc-ellipsis">
<h3><a class="doc-anchor" href="#doc-ellipsis">#</a> <code>ellipsis</code></h3>
<p><code>ellipsis</code> — string quote / escape builtin.</p>
<pre><code class="lang-perl">my $result = ellipsis $x
# or in a pipeline:
@list |> map ellipsis |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-elof">
<h3><a class="doc-anchor" href="#doc-elof">#</a> <code>elof</code></h3>
<p><code>elof</code> — haskell list functions builtin. Alias for <code>elem_of</code>.</p>
<pre><code class="lang-perl">my $result = elof $x
# or in a pipeline:
@list |> map elof |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-elu">
<h3><a class="doc-anchor" href="#doc-elu">#</a> <code>elu</code></h3>
<p><code>elu</code> applies the Exponential Linear Unit: x if x≥0, alpha*(e^x - 1) otherwise.</p>
<pre><code class="lang-perl">p elu(1) # 1
p elu(-1) # -0.632
</code></pre>
</article>
<article class="doc-entry" id="doc-email-domain">
<h3><a class="doc-anchor" href="#doc-email-domain">#</a> <code>email_domain</code></h3>
<p><code>email_domain</code> — url / email parts builtin.</p>
<pre><code class="lang-perl">my $result = email_domain $x
# or in a pipeline:
@list |> map email_domain |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-email-local">
<h3><a class="doc-anchor" href="#doc-email-local">#</a> <code>email_local</code></h3>
<p><code>email_local</code> — url / email parts builtin.</p>
<pre><code class="lang-perl">my $result = email_local $x
# or in a pipeline:
@list |> map email_local |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-emass">
<h3><a class="doc-anchor" href="#doc-emass">#</a> <code>emass</code></h3>
<p><code>emass</code> — constants builtin. Alias for <code>electron_mass</code>.</p>
<pre><code class="lang-perl">my $result = emass $x
# or in a pipeline:
@list |> map emass |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-emavg">
<h3><a class="doc-anchor" href="#doc-emavg">#</a> <code>emavg</code></h3>
<p><code>emavg</code> — math / numeric (uncategorized batch) builtin. Alias for <code>exponential_moving_average</code>.</p>
<pre><code class="lang-perl">my $result = emavg $x
# or in a pipeline:
@list |> map emavg |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-embed">
<h3><a class="doc-anchor" href="#doc-embed">#</a> <code>embed</code></h3>
<p><code>embed</code> — time-delay embedding. Converts a time series into a matrix of lagged values. Like R's embed().</p>
<pre><code class="lang-perl">p embed([1,2,3,4,5], 3) # [[3,2,1],[4,3,2],[5,4,3]]
</code></pre>
</article>
<article class="doc-entry" id="doc-emojinum">
<h3><a class="doc-anchor" href="#doc-emojinum">#</a> <code>emojinum</code></h3>
<p><code>emojinum</code> — encoding / phonetics builtin. Alias for <code>to_emoji_num</code>.</p>
<pre><code class="lang-perl">my $result = emojinum $x
# or in a pipeline:
@list |> map emojinum |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-empc">
<h3><a class="doc-anchor" href="#doc-empc">#</a> <code>empc</code></h3>
<p><code>empc</code> — algebraic match builtin. Alias for <code>empty_clj</code>.</p>
<pre><code class="lang-perl">my $result = empc $x
# or in a pipeline:
@list |> map empc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-empty-clj">
<h3><a class="doc-anchor" href="#doc-empty-clj">#</a> <code>empty_clj</code></h3>
<p><code>empty_clj</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = empty_clj $x
# or in a pipeline:
@list |> map empty_clj |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-empty-count">
<h3><a class="doc-anchor" href="#doc-empty-count">#</a> <code>empty_count</code></h3>
<p><code>empty_count</code> — counters (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = empty_count $x
# or in a pipeline:
@list |> map empty_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-end-of-day">
<h3><a class="doc-anchor" href="#doc-end-of-day">#</a> <code>end_of_day</code></h3>
<p><code>end_of_day</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = end_of_day $x
# or in a pipeline:
@list |> map end_of_day |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-endgrent">
<h3><a class="doc-anchor" href="#doc-endgrent">#</a> <code>endgrent</code></h3>
<p><code>endgrent</code> — posix metadata builtin.</p>
<pre><code class="lang-perl">my $result = endgrent $x
# or in a pipeline:
@list |> map endgrent |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-endhostent">
<h3><a class="doc-anchor" href="#doc-endhostent">#</a> <code>endhostent</code></h3>
<p><code>endhostent</code> — posix metadata builtin.</p>
<pre><code class="lang-perl">my $result = endhostent $x
# or in a pipeline:
@list |> map endhostent |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-endianness">
<h3><a class="doc-anchor" href="#doc-endianness">#</a> <code>endianness</code></h3>
<p><code>endianness</code> — byte order of the platform: <code>"little"</code> or <code>"big"</code>. Compile-time constant.</p>
<pre><code class="lang-perl">p endianness # little
</code></pre>
</article>
<article class="doc-entry" id="doc-endnetent">
<h3><a class="doc-anchor" href="#doc-endnetent">#</a> <code>endnetent</code></h3>
<p><code>endnetent</code> — posix metadata builtin.</p>
<pre><code class="lang-perl">my $result = endnetent $x
# or in a pipeline:
@list |> map endnetent |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-endprotoent">
<h3><a class="doc-anchor" href="#doc-endprotoent">#</a> <code>endprotoent</code></h3>
<p><code>endprotoent</code> — posix metadata builtin.</p>
<pre><code class="lang-perl">my $result = endprotoent $x
# or in a pipeline:
@list |> map endprotoent |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-endpwent">
<h3><a class="doc-anchor" href="#doc-endpwent">#</a> <code>endpwent</code></h3>
<p><code>endpwent</code> — posix metadata builtin.</p>
<pre><code class="lang-perl">my $result = endpwent $x
# or in a pipeline:
@list |> map endpwent |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ends-with">
<h3><a class="doc-anchor" href="#doc-ends-with">#</a> <code>ends_with</code></h3>
<p><code>ends_with</code> — trivial string ops builtin.</p>
<pre><code class="lang-perl">my $result = ends_with $x
# or in a pipeline:
@list |> map ends_with |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ends-with-any">
<h3><a class="doc-anchor" href="#doc-ends-with-any">#</a> <code>ends_with_any</code></h3>
<p><code>ends_with_any</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = ends_with_any $x
# or in a pipeline:
@list |> map ends_with_any |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-endservent">
<h3><a class="doc-anchor" href="#doc-endservent">#</a> <code>endservent</code></h3>
<p><code>endservent</code> — posix metadata builtin.</p>
<pre><code class="lang-perl">my $result = endservent $x
# or in a pipeline:
@list |> map endservent |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-energy">
<h3><a class="doc-anchor" href="#doc-energy">#</a> <code>energy</code></h3>
<p><code>energy(\@signal)</code> — computes the total energy of a signal as the sum of squared samples. Useful for audio analysis and feature extraction.</p>
<pre><code class="lang-perl">p energy(\@signal) # total signal energy
</code></pre>
</article>
<article class="doc-entry" id="doc-ensure-prefix">
<h3><a class="doc-anchor" href="#doc-ensure-prefix">#</a> <code>ensure_prefix</code></h3>
<p><code>ensure_prefix</code> — path helpers builtin.</p>
<pre><code class="lang-perl">my $result = ensure_prefix $x
# or in a pipeline:
@list |> map ensure_prefix |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ensure-suffix">
<h3><a class="doc-anchor" href="#doc-ensure-suffix">#</a> <code>ensure_suffix</code></h3>
<p><code>ensure_suffix</code> — path helpers builtin.</p>
<pre><code class="lang-perl">my $result = ensure_suffix $x
# or in a pipeline:
@list |> map ensure_suffix |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-entropy">
<h3><a class="doc-anchor" href="#doc-entropy">#</a> <code>entropy</code></h3>
<p><code>entropy</code> — math functions builtin.</p>
<pre><code class="lang-perl">my $result = entropy $x
# or in a pipeline:
@list |> map entropy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-env">
<h3><a class="doc-anchor" href="#doc-env">#</a> <code>env</code></h3>
<p><code>env</code> — dsp / signal (extended) builtin. Alias for <code>envelope</code>.</p>
<pre><code class="lang-perl">my $result = env $x
# or in a pipeline:
@list |> map env |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-env-get">
<h3><a class="doc-anchor" href="#doc-env-get">#</a> <code>env_get</code></h3>
<p><code>env_get</code> — process / env builtin.</p>
<pre><code class="lang-perl">my $result = env_get $x
# or in a pipeline:
@list |> map env_get |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-env-has">
<h3><a class="doc-anchor" href="#doc-env-has">#</a> <code>env_has</code></h3>
<p><code>env_has</code> — process / env builtin.</p>
<pre><code class="lang-perl">my $result = env_has $x
# or in a pipeline:
@list |> map env_has |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-env-keys">
<h3><a class="doc-anchor" href="#doc-env-keys">#</a> <code>env_keys</code></h3>
<p><code>env_keys</code> — process / env builtin.</p>
<pre><code class="lang-perl">my $result = env_keys $x
# or in a pipeline:
@list |> map env_keys |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-env-pairs">
<h3><a class="doc-anchor" href="#doc-env-pairs">#</a> <code>env_pairs</code></h3>
<p><code>env_pairs</code> — more process / system builtin.</p>
<pre><code class="lang-perl">my $result = env_pairs $x
# or in a pipeline:
@list |> map env_pairs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-env-remove">
<h3><a class="doc-anchor" href="#doc-env-remove">#</a> <code>env_remove</code></h3>
<p><code>env_remove</code> — more process / system builtin.</p>
<pre><code class="lang-perl">my $result = env_remove $x
# or in a pipeline:
@list |> map env_remove |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-env-set">
<h3><a class="doc-anchor" href="#doc-env-set">#</a> <code>env_set</code></h3>
<p><code>env_set</code> — more process / system builtin.</p>
<pre><code class="lang-perl">my $result = env_set $x
# or in a pipeline:
@list |> map env_set |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-envelope">
<h3><a class="doc-anchor" href="#doc-envelope">#</a> <code>envelope</code></h3>
<p><code>envelope(\@signal)</code> (alias <code>hilbert_env</code>) — computes the amplitude envelope using Hilbert transform magnitude. Useful for amplitude modulation analysis.</p>
<pre><code class="lang-perl">my $env = envelope(\@signal)
# $env traces the amplitude of oscillations
</code></pre>
</article>
<article class="doc-entry" id="doc-eod">
<h3><a class="doc-anchor" href="#doc-eod">#</a> <code>eod</code></h3>
<p><code>eod</code> — extended stdlib builtin. Alias for <code>end_of_day</code>.</p>
<pre><code class="lang-perl">my $result = eod $x
# or in a pipeline:
@list |> map eod |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-epoch">
<h3><a class="doc-anchor" href="#doc-epoch">#</a> <code>epoch</code></h3>
<p><code>epoch</code> — now / timestamp builtin. Alias for <code>unix_epoch</code>.</p>
<pre><code class="lang-perl">my $result = epoch $x
# or in a pipeline:
@list |> map epoch |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-epoch-ms">
<h3><a class="doc-anchor" href="#doc-epoch-ms">#</a> <code>epoch_ms</code></h3>
<p><code>epoch_ms</code> — now / timestamp builtin. Alias for <code>unix_epoch_ms</code>.</p>
<pre><code class="lang-perl">my $result = epoch_ms $x
# or in a pipeline:
@list |> map epoch_ms |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-eps">
<h3><a class="doc-anchor" href="#doc-eps">#</a> <code>eps</code></h3>
<p><code>eps</code> — math / numeric (uncategorized batch) builtin. Alias for <code>epsilon</code>.</p>
<pre><code class="lang-perl">my $result = eps $x
# or in a pipeline:
@list |> map eps |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-epsilon">
<h3><a class="doc-anchor" href="#doc-epsilon">#</a> <code>epsilon</code></h3>
<p><code>epsilon</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = epsilon $x
# or in a pipeline:
@list |> map epsilon |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-epsilon0">
<h3><a class="doc-anchor" href="#doc-epsilon0">#</a> <code>epsilon0</code></h3>
<p><code>vacuum_permittivity</code> (alias <code>epsilon0</code>) — ε₀ ≈ 8.854×10⁻¹² F/m. Electric constant, permittivity of free space.</p>
<pre><code class="lang-perl">p epsilon0 # 8.8541878128e-12
</code></pre>
</article>
<article class="doc-entry" id="doc-eqidx">
<h3><a class="doc-anchor" href="#doc-eqidx">#</a> <code>eqidx</code></h3>
<p><code>eqidx</code> — extended stdlib batch 3 builtin. Alias for <code>equilibrium_index</code>.</p>
<pre><code class="lang-perl">my $result = eqidx $x
# or in a pipeline:
@list |> map eqidx |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-eqrng">
<h3><a class="doc-anchor" href="#doc-eqrng">#</a> <code>eqrng</code></h3>
<p><code>eqrng</code> — extended stdlib builtin. Alias for <code>equal_range</code>.</p>
<pre><code class="lang-perl">my $result = eqrng $x
# or in a pipeline:
@list |> map eqrng |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-equal-range">
<h3><a class="doc-anchor" href="#doc-equal-range">#</a> <code>equal_range</code></h3>
<p><code>equal_range</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = equal_range $x
# or in a pipeline:
@list |> map equal_range |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-equilibrium-index">
<h3><a class="doc-anchor" href="#doc-equilibrium-index">#</a> <code>equilibrium_index</code></h3>
<p><code>equilibrium_index</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = equilibrium_index $x
# or in a pipeline:
@list |> map equilibrium_index |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-erf-approx">
<h3><a class="doc-anchor" href="#doc-erf-approx">#</a> <code>erf_approx</code></h3>
<p><code>erf_approx($x)</code> — error function. Used in probability, statistics, and partial differential equations.</p>
<pre><code class="lang-perl">p erf(1) # ~0.843
p erf(2) # ~0.995
</code></pre>
</article>
<article class="doc-entry" id="doc-escape-json">
<h3><a class="doc-anchor" href="#doc-escape-json">#</a> <code>escape_json</code></h3>
<p><code>escape_json</code> — json helpers builtin.</p>
<pre><code class="lang-perl">my $result = escape_json $x
# or in a pipeline:
@list |> map escape_json |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-escape-velocity">
<h3><a class="doc-anchor" href="#doc-escape-velocity">#</a> <code>escape_velocity</code></h3>
<p><code>escape_velocity($mass, $radius)</code> (alias <code>escvel</code>) — minimum velocity to escape gravitational field: v = √(2GM/r). Defaults to Earth values.</p>
<pre><code class="lang-perl">p escvel # ~11186 m/s (Earth)
p escvel(1.989e30, 6.96e8) # ~617 km/s (Sun)
</code></pre>
</article>
<article class="doc-entry" id="doc-eslice">
<h3><a class="doc-anchor" href="#doc-eslice">#</a> <code>eslice</code></h3>
<p><code>eslice</code> — python/ruby stdlib builtin. Alias for <code>each_slice</code>.</p>
<pre><code class="lang-perl">my $result = eslice $x
# or in a pipeline:
@list |> map eslice |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-etot">
<h3><a class="doc-anchor" href="#doc-etot">#</a> <code>etot</code></h3>
<p><code>etot</code> — extended stdlib batch 3 builtin. Alias for <code>euler_totient</code>.</p>
<pre><code class="lang-perl">my $result = etot $x
# or in a pipeline:
@list |> map etot |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-eucdist">
<h3><a class="doc-anchor" href="#doc-eucdist">#</a> <code>eucdist</code></h3>
<p><code>eucdist</code> — math / numeric (uncategorized batch) builtin. Alias for <code>euclidean_distance</code>.</p>
<pre><code class="lang-perl">my $result = eucdist $x
# or in a pipeline:
@list |> map eucdist |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-euclidean-distance">
<h3><a class="doc-anchor" href="#doc-euclidean-distance">#</a> <code>euclidean_distance</code></h3>
<p><code>euclidean_distance</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = euclidean_distance $x
# or in a pipeline:
@list |> map euclidean_distance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-euler-e">
<h3><a class="doc-anchor" href="#doc-euler-e">#</a> <code>euler_e</code></h3>
<p><code>euler_e</code> — math / numeric (uncategorized batch) builtin. Alias for <code>euler_number</code>.</p>
<pre><code class="lang-perl">my $result = euler_e $x
# or in a pipeline:
@list |> map euler_e |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-euler-mascheroni">
<h3><a class="doc-anchor" href="#doc-euler-mascheroni">#</a> <code>euler_mascheroni</code></h3>
<p><code>euler_mascheroni</code> (alias <code>gamma_const</code>) — Euler-Mascheroni constant γ ≈ 0.5772. Appears in number theory and analysis.</p>
<pre><code class="lang-perl">p euler_mascheroni # 0.5772156649015329
</code></pre>
</article>
<article class="doc-entry" id="doc-euler-method">
<h3><a class="doc-anchor" href="#doc-euler-method">#</a> <code>euler_method</code></h3>
<p><code>euler_ode</code> (alias <code>euler_method</code>) solves an ODE dy/dt = f(t,y) using the Euler method. Returns [[t,y], ...].</p>
<pre><code class="lang-perl">my $sol = euler_ode(fn { $_[1] }, 0, 1, 0.01, 100) # exponential growth
</code></pre>
</article>
<article class="doc-entry" id="doc-euler-number">
<h3><a class="doc-anchor" href="#doc-euler-number">#</a> <code>euler_number</code></h3>
<p><code>euler_number</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = euler_number $x
# or in a pipeline:
@list |> map euler_number |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-euler-totient">
<h3><a class="doc-anchor" href="#doc-euler-totient">#</a> <code>euler_totient</code></h3>
<p><code>euler_totient</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = euler_totient $x
# or in a pipeline:
@list |> map euler_totient |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-eval-rpn">
<h3><a class="doc-anchor" href="#doc-eval-rpn">#</a> <code>eval_rpn</code></h3>
<p><code>eval_rpn</code> — algorithms / puzzles builtin.</p>
<pre><code class="lang-perl">my $result = eval_rpn $x
# or in a pipeline:
@list |> map eval_rpn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-even">
<h3><a class="doc-anchor" href="#doc-even">#</a> <code>even</code></h3>
<p><code>even</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = even $x
# or in a pipeline:
@list |> map even |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-every-nth">
<h3><a class="doc-anchor" href="#doc-every-nth">#</a> <code>every_nth</code></h3>
<p><code>every_nth</code> — collection helpers (trivial) builtin.</p>
<pre><code class="lang-perl">my $result = every_nth $x
# or in a pipeline:
@list |> map every_nth |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ew">
<h3><a class="doc-anchor" href="#doc-ew">#</a> <code>ew</code></h3>
<p><code>ew</code> — trivial string ops builtin. Alias for <code>ends_with</code>.</p>
<pre><code class="lang-perl">my $result = ew $x
# or in a pipeline:
@list |> map ew |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ewo">
<h3><a class="doc-anchor" href="#doc-ewo">#</a> <code>ewo</code></h3>
<p><code>ewo</code> — additional missing stdlib functions builtin. Alias for <code>each_with_object</code>.</p>
<pre><code class="lang-perl">my $result = ewo $x
# or in a pipeline:
@list |> map ewo |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-exp2">
<h3><a class="doc-anchor" href="#doc-exp2">#</a> <code>exp2</code></h3>
<p><code>exp2</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = exp2 $x
# or in a pipeline:
@list |> map exp2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-exponential-moving-average">
<h3><a class="doc-anchor" href="#doc-exponential-moving-average">#</a> <code>exponential_moving_average</code></h3>
<p><code>exponential_moving_average</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = exponential_moving_average $x
# or in a pipeline:
@list |> map exponential_moving_average |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-exponential-pdf">
<h3><a class="doc-anchor" href="#doc-exponential-pdf">#</a> <code>exponential_pdf</code></h3>
<p><code>exponential_pdf</code> — math formulas builtin.</p>
<pre><code class="lang-perl">my $result = exponential_pdf $x
# or in a pipeline:
@list |> map exponential_pdf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-exppdf">
<h3><a class="doc-anchor" href="#doc-exppdf">#</a> <code>exppdf</code></h3>
<p><code>exppdf</code> — math formulas builtin. Alias for <code>exponential_pdf</code>.</p>
<pre><code class="lang-perl">my $result = exppdf $x
# or in a pipeline:
@list |> map exppdf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-extract-between">
<h3><a class="doc-anchor" href="#doc-extract-between">#</a> <code>extract_between</code></h3>
<p><code>extract_between</code> — string quote / escape builtin.</p>
<pre><code class="lang-perl">my $result = extract_between $x
# or in a pipeline:
@list |> map extract_between |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-eye">
<h3><a class="doc-anchor" href="#doc-eye">#</a> <code>eye</code></h3>
<p><code>eye</code> — matrix / linear algebra builtin. Alias for <code>identity_matrix</code>.</p>
<pre><code class="lang-perl">my $result = eye $x
# or in a pipeline:
@list |> map eye |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-f">
<h3><a class="doc-anchor" href="#doc-f">#</a> <code>f</code></h3>
<p><code>f</code> — filesystem extensions builtin.</p>
<pre><code class="lang-perl">my $result = f $x
# or in a pipeline:
@list |> map f |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-f64-max">
<h3><a class="doc-anchor" href="#doc-f64-max">#</a> <code>f64_max</code></h3>
<p><code>f64_max</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = f64_max $x
# or in a pipeline:
@list |> map f64_max |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-f64-min">
<h3><a class="doc-anchor" href="#doc-f64-min">#</a> <code>f64_min</code></h3>
<p><code>f64_min</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = f64_min $x
# or in a pipeline:
@list |> map f64_min |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-f-pdf">
<h3><a class="doc-anchor" href="#doc-f-pdf">#</a> <code>f_pdf</code></h3>
<p><code>f_pdf</code> (alias <code>fpdf</code>) evaluates the F-distribution PDF at x with d1 and d2 degrees of freedom.</p>
<pre><code class="lang-perl">p fpdf(1.0, 5, 10)
</code></pre>
</article>
<article class="doc-entry" id="doc-f-to-c">
<h3><a class="doc-anchor" href="#doc-f-to-c">#</a> <code>f_to_c</code></h3>
<p><code>f_to_c</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = f_to_c $input
</code></pre>
</article>
<article class="doc-entry" id="doc-f-to-k">
<h3><a class="doc-anchor" href="#doc-f-to-k">#</a> <code>f_to_k</code></h3>
<p><code>f_to_k</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = f_to_k $input
</code></pre>
</article>
<article class="doc-entry" id="doc-fact">
<h3><a class="doc-anchor" href="#doc-fact">#</a> <code>fact</code></h3>
<p><code>fact</code> — trivial numeric / predicate builtins builtin. Alias for <code>factorial</code>.</p>
<pre><code class="lang-perl">my $result = fact $x
# or in a pipeline:
@list |> map fact |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-factorial">
<h3><a class="doc-anchor" href="#doc-factorial">#</a> <code>factorial</code></h3>
<p><code>factorial</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = factorial $x
# or in a pipeline:
@list |> map factorial |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-falf">
<h3><a class="doc-anchor" href="#doc-falf">#</a> <code>falf</code></h3>
<p><code>falf</code> — python/ruby stdlib builtin. Alias for <code>filterfalse</code>.</p>
<pre><code class="lang-perl">my $result = falf $x
# or in a pipeline:
@list |> map falf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fallback">
<h3><a class="doc-anchor" href="#doc-fallback">#</a> <code>fallback</code></h3>
<p><code>fallback</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = fallback $x
# or in a pipeline:
@list |> map fallback |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-falling-factorial">
<h3><a class="doc-anchor" href="#doc-falling-factorial">#</a> <code>falling_factorial</code></h3>
<p><code>falling_factorial</code> — math formulas builtin.</p>
<pre><code class="lang-perl">my $result = falling_factorial $x
# or in a pipeline:
@list |> map falling_factorial |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-falsy-count">
<h3><a class="doc-anchor" href="#doc-falsy-count">#</a> <code>falsy_count</code></h3>
<p><code>falsy_count</code> — counters (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = falsy_count $x
# or in a pipeline:
@list |> map falsy_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-faraday">
<h3><a class="doc-anchor" href="#doc-faraday">#</a> <code>faraday</code></h3>
<p><code>faraday_constant</code> (alias <code>faraday</code>) — F ≈ 96485 C/mol. Charge per mole of electrons.</p>
<pre><code class="lang-perl">p faraday # 96485.33212
</code></pre>
</article>
<article class="doc-entry" id="doc-fb">
<h3><a class="doc-anchor" href="#doc-fb">#</a> <code>fb</code></h3>
<p><code>fb</code> — algorithms / puzzles builtin. Alias for <code>fizzbuzz</code>.</p>
<pre><code class="lang-perl">my $result = fb $x
# or in a pipeline:
@list |> map fb |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fcntl">
<h3><a class="doc-anchor" href="#doc-fcntl">#</a> <code>fcntl</code></h3>
<p><code>fcntl</code> — ipc builtin.</p>
<pre><code class="lang-perl">my $result = fcntl $x
# or in a pipeline:
@list |> map fcntl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fcp">
<h3><a class="doc-anchor" href="#doc-fcp">#</a> <code>fcp</code></h3>
<p><code>fcp</code> — extended stdlib builtin. Alias for <code>from_code_point</code>.</p>
<pre><code class="lang-perl">my $result = fcp $x
# or in a pipeline:
@list |> map fcp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fdivop">
<h3><a class="doc-anchor" href="#doc-fdivop">#</a> <code>fdivop</code></h3>
<p><code>fdivop</code> — extended stdlib builtin. Alias for <code>floor_div_op</code>.</p>
<pre><code class="lang-perl">my $result = fdivop $x
# or in a pipeline:
@list |> map fdivop |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-feet-to-m">
<h3><a class="doc-anchor" href="#doc-feet-to-m">#</a> <code>feet_to_m</code></h3>
<p><code>feet_to_m</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = feet_to_m $input
</code></pre>
</article>
<article class="doc-entry" id="doc-feiga">
<h3><a class="doc-anchor" href="#doc-feiga">#</a> <code>feiga</code></h3>
<p><code>feiga</code> — math constants builtin. Alias for <code>feigenbaum_alpha</code>.</p>
<pre><code class="lang-perl">my $result = feiga $x
# or in a pipeline:
@list |> map feiga |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-feigd">
<h3><a class="doc-anchor" href="#doc-feigd">#</a> <code>feigd</code></h3>
<p><code>feigenbaum_delta</code> (alias <code>feigd</code>) — Feigenbaum constant δ ≈ 4.669. Universal constant in chaos theory.</p>
<pre><code class="lang-perl">p feigd # 4.669201609102990
</code></pre>
</article>
<article class="doc-entry" id="doc-feigenbaum-alpha">
<h3><a class="doc-anchor" href="#doc-feigenbaum-alpha">#</a> <code>feigenbaum_alpha</code></h3>
<p><code>feigenbaum_alpha</code> — math constants builtin.</p>
<pre><code class="lang-perl">my $result = feigenbaum_alpha $x
# or in a pipeline:
@list |> map feigenbaum_alpha |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fetch-val">
<h3><a class="doc-anchor" href="#doc-fetch-val">#</a> <code>fetch_val</code></h3>
<p><code>fetch_val</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = fetch_val $x
# or in a pipeline:
@list |> map fetch_val |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ffact">
<h3><a class="doc-anchor" href="#doc-ffact">#</a> <code>ffact</code></h3>
<p><code>ffact</code> — math formulas builtin. Alias for <code>falling_factorial</code>.</p>
<pre><code class="lang-perl">my $result = ffact $x
# or in a pipeline:
@list |> map ffact |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ffirst">
<h3><a class="doc-anchor" href="#doc-ffirst">#</a> <code>ffirst</code></h3>
<p><code>ffirst</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = ffirst $x
# or in a pipeline:
@list |> map ffirst |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ffs">
<h3><a class="doc-anchor" href="#doc-ffs">#</a> <code>ffs</code></h3>
<p><code>ffs</code> — algebraic match builtin. Alias for <code>ffirst</code>.</p>
<pre><code class="lang-perl">my $result = ffs $x
# or in a pipeline:
@list |> map ffs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fft-magnitude">
<h3><a class="doc-anchor" href="#doc-fft-magnitude">#</a> <code>fft_magnitude</code></h3>
<p><code>fft_magnitude</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = fft_magnitude $x
# or in a pipeline:
@list |> map fft_magnitude |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fftmag">
<h3><a class="doc-anchor" href="#doc-fftmag">#</a> <code>fftmag</code></h3>
<p><code>fftmag</code> — math / numeric (uncategorized batch) builtin. Alias for <code>fft_magnitude</code>.</p>
<pre><code class="lang-perl">my $result = fftmag $x
# or in a pipeline:
@list |> map fftmag |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fib">
<h3><a class="doc-anchor" href="#doc-fib">#</a> <code>fib</code></h3>
<p><code>fib</code> — trivial numeric / predicate builtins builtin. Alias for <code>fibonacci</code>.</p>
<pre><code class="lang-perl">my $result = fib $x
# or in a pipeline:
@list |> map fib |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fibonacci">
<h3><a class="doc-anchor" href="#doc-fibonacci">#</a> <code>fibonacci</code></h3>
<p><code>fibonacci</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = fibonacci $x
# or in a pipeline:
@list |> map fibonacci |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fibonacci-seq">
<h3><a class="doc-anchor" href="#doc-fibonacci-seq">#</a> <code>fibonacci_seq</code></h3>
<p><code>fibonacci_seq</code> — sequences builtin.</p>
<pre><code class="lang-perl">my $result = fibonacci_seq $x
# or in a pipeline:
@list |> map fibonacci_seq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fidx">
<h3><a class="doc-anchor" href="#doc-fidx">#</a> <code>fidx</code></h3>
<p><code>fidx</code> — python/ruby stdlib builtin. Alias for <code>find_index_fn</code>.</p>
<pre><code class="lang-perl">my $result = fidx $x
# or in a pipeline:
@list |> map fidx |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-file-atime">
<h3><a class="doc-anchor" href="#doc-file-atime">#</a> <code>file_atime</code></h3>
<p><code>file_atime</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = file_atime $x
# or in a pipeline:
@list |> map file_atime |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-file-ctime">
<h3><a class="doc-anchor" href="#doc-file-ctime">#</a> <code>file_ctime</code></h3>
<p><code>file_ctime</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = file_ctime $x
# or in a pipeline:
@list |> map file_ctime |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-file-mtime">
<h3><a class="doc-anchor" href="#doc-file-mtime">#</a> <code>file_mtime</code></h3>
<p><code>file_mtime</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = file_mtime $x
# or in a pipeline:
@list |> map file_mtime |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-file-size">
<h3><a class="doc-anchor" href="#doc-file-size">#</a> <code>file_size</code></h3>
<p><code>file_size</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = file_size $x
# or in a pipeline:
@list |> map file_size |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-files">
<h3><a class="doc-anchor" href="#doc-files">#</a> <code>files</code></h3>
<p><code>files</code> — filesystem extensions builtin.</p>
<pre><code class="lang-perl">my $result = files $x
# or in a pipeline:
@list |> map files |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-filesf">
<h3><a class="doc-anchor" href="#doc-filesf">#</a> <code>filesf</code></h3>
<p><code>filesf</code> — filesystem extensions builtin.</p>
<pre><code class="lang-perl">my $result = filesf $x
# or in a pipeline:
@list |> map filesf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fill-arr">
<h3><a class="doc-anchor" href="#doc-fill-arr">#</a> <code>fill_arr</code></h3>
<p><code>fill_arr</code> — javascript array/object methods builtin.</p>
<pre><code class="lang-perl">my $result = fill_arr $x
# or in a pipeline:
@list |> map fill_arr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-filla">
<h3><a class="doc-anchor" href="#doc-filla">#</a> <code>filla</code></h3>
<p><code>filla</code> — javascript array/object methods builtin. Alias for <code>fill_arr</code>.</p>
<pre><code class="lang-perl">my $result = filla $x
# or in a pipeline:
@list |> map filla |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-filter-chars">
<h3><a class="doc-anchor" href="#doc-filter-chars">#</a> <code>filter_chars</code></h3>
<p><code>filter_chars</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = filter_chars $x
# or in a pipeline:
@list |> map filter_chars |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-filter-indexed">
<h3><a class="doc-anchor" href="#doc-filter-indexed">#</a> <code>filter_indexed</code></h3>
<p><code>filter_indexed</code> — go/general functional utilities builtin.</p>
<pre><code class="lang-perl">my $result = filter_indexed $x
# or in a pipeline:
@list |> map filter_indexed |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-filter-map">
<h3><a class="doc-anchor" href="#doc-filter-map">#</a> <code>filter_map</code></h3>
<p><code>filter_map</code> — rust iterator methods builtin.</p>
<pre><code class="lang-perl">my $result = filter_map $x
# or in a pipeline:
@list |> map filter_map |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-filter-ts">
<h3><a class="doc-anchor" href="#doc-filter-ts">#</a> <code>filter_ts</code></h3>
<p><code>ts_filter</code> — linear convolution filter. Like R's filter(method='convolution').</p>
<pre><code class="lang-perl">my @smooth = @{ts_filter([1,5,2,8,3], [0.25,0.5,0.25])}
</code></pre>
</article>
<article class="doc-entry" id="doc-filterfalse">
<h3><a class="doc-anchor" href="#doc-filterfalse">#</a> <code>filterfalse</code></h3>
<p><code>filterfalse</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = filterfalse $x
# or in a pipeline:
@list |> map filterfalse |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-find">
<h3><a class="doc-anchor" href="#doc-find">#</a> <code>find</code></h3>
<p><code>find</code> — functional / iterator builtin.</p>
<pre><code class="lang-perl">my $result = find $x
# or in a pipeline:
@list |> map find |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-findinterval">
<h3><a class="doc-anchor" href="#doc-findinterval">#</a> <code>findInterval</code></h3>
<p><code>find_interval</code> — for each x, find which interval in breaks it falls into. Like R's findInterval().</p>
<pre><code class="lang-perl">p findInterval([1.5, 3.5, 7.5], [0, 2, 5, 10]) # [1, 2, 3]
</code></pre>
</article>
<article class="doc-entry" id="doc-find-all">
<h3><a class="doc-anchor" href="#doc-find-all">#</a> <code>find_all</code></h3>
<p><code>find_all</code> — functional / iterator builtin.</p>
<pre><code class="lang-perl">my $result = find_all $x
# or in a pipeline:
@list |> map find_all |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-find-all-indices">
<h3><a class="doc-anchor" href="#doc-find-all-indices">#</a> <code>find_all_indices</code></h3>
<p><code>find_all_indices</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = find_all_indices $x
# or in a pipeline:
@list |> map find_all_indices |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-find-first">
<h3><a class="doc-anchor" href="#doc-find-first">#</a> <code>find_first</code></h3>
<p><code>find_first</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = find_first $x
# or in a pipeline:
@list |> map find_first |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-find-index">
<h3><a class="doc-anchor" href="#doc-find-index">#</a> <code>find_index</code></h3>
<p><code>find_index</code> — functional / iterator builtin.</p>
<pre><code class="lang-perl">my $result = find_index $x
# or in a pipeline:
@list |> map find_index |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-find-index-fn">
<h3><a class="doc-anchor" href="#doc-find-index-fn">#</a> <code>find_index_fn</code></h3>
<p><code>find_index_fn</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = find_index_fn $x
# or in a pipeline:
@list |> map find_index_fn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-find-indices">
<h3><a class="doc-anchor" href="#doc-find-indices">#</a> <code>find_indices</code></h3>
<p><code>find_indices</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = find_indices $x
# or in a pipeline:
@list |> map find_indices |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-find-last">
<h3><a class="doc-anchor" href="#doc-find-last">#</a> <code>find_last</code></h3>
<p><code>find_last</code> — javascript array/object methods builtin.</p>
<pre><code class="lang-perl">my $result = find_last $x
# or in a pipeline:
@list |> map find_last |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-find-last-index">
<h3><a class="doc-anchor" href="#doc-find-last-index">#</a> <code>find_last_index</code></h3>
<p><code>find_last_index</code> — javascript array/object methods builtin.</p>
<pre><code class="lang-perl">my $result = find_last_index $x
# or in a pipeline:
@list |> map find_last_index |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-find-map">
<h3><a class="doc-anchor" href="#doc-find-map">#</a> <code>find_map</code></h3>
<p><code>find_map</code> — rust iterator methods builtin.</p>
<pre><code class="lang-perl">my $result = find_map $x
# or in a pipeline:
@list |> map find_map |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-first-arg">
<h3><a class="doc-anchor" href="#doc-first-arg">#</a> <code>first_arg</code></h3>
<p><code>first_arg</code> — functional primitives builtin.</p>
<pre><code class="lang-perl">my $result = first_arg $x
# or in a pipeline:
@list |> map first_arg |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-first-elem">
<h3><a class="doc-anchor" href="#doc-first-elem">#</a> <code>first_elem</code></h3>
<p><code>first_elem</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = first_elem $x
# or in a pipeline:
@list |> map first_elem |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-first-eq">
<h3><a class="doc-anchor" href="#doc-first-eq">#</a> <code>first_eq</code></h3>
<p><code>first_eq</code> — collection (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = first_eq $x
# or in a pipeline:
@list |> map first_eq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-first-word">
<h3><a class="doc-anchor" href="#doc-first-word">#</a> <code>first_word</code></h3>
<p><code>first_word</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = first_word $x
# or in a pipeline:
@list |> map first_word |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-five-number-summary">
<h3><a class="doc-anchor" href="#doc-five-number-summary">#</a> <code>five_number_summary</code></h3>
<p><code>five_number_summary(@data)</code> (alias <code>fivenum</code>) — returns [min, Q1, median, Q3, max], the classic five-number summary used for box plots. Provides a quick view of data distribution.</p>
<pre><code class="lang-perl">my @data = 1..100
my $f = fivenum(@data)
p "min=$f->[0] Q1=$f->[1] med=$f->[2] Q3=$f->[3] max=$f->[4]"
</code></pre>
</article>
<article class="doc-entry" id="doc-fizzbuzz">
<h3><a class="doc-anchor" href="#doc-fizzbuzz">#</a> <code>fizzbuzz</code></h3>
<p><code>fizzbuzz</code> — algorithms / puzzles builtin.</p>
<pre><code class="lang-perl">my $result = fizzbuzz $x
# or in a pipeline:
@list |> map fizzbuzz |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-flat-depth">
<h3><a class="doc-anchor" href="#doc-flat-depth">#</a> <code>flat_depth</code></h3>
<p><code>flat_depth</code> — javascript array/object methods builtin.</p>
<pre><code class="lang-perl">my $result = flat_depth $x
# or in a pipeline:
@list |> map flat_depth |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-flat-map">
<h3><a class="doc-anchor" href="#doc-flat-map">#</a> <code>flat_map</code></h3>
<p><code>flat_map</code> — functional / iterator builtin.</p>
<pre><code class="lang-perl">my $result = flat_map $x
# or in a pipeline:
@list |> map flat_map |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-flat-map-fn">
<h3><a class="doc-anchor" href="#doc-flat-map-fn">#</a> <code>flat_map_fn</code></h3>
<p><code>flat_map_fn</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = flat_map_fn $x
# or in a pipeline:
@list |> map flat_map_fn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-flat-maps">
<h3><a class="doc-anchor" href="#doc-flat-maps">#</a> <code>flat_maps</code></h3>
<p><code>flat_maps { BLOCK } LIST</code> — a lazy streaming flat-map that evaluates the block for each element and flattens the resulting lists into a single iterator. Where <code>maps</code> expects the block to return one value, <code>flat_maps</code> handles blocks that return zero or more values per element and concatenates them seamlessly. This is the streaming equivalent of calling <code>map</code> with a multi-value block. Use it in <code>|></code> chains when each input element fans out into multiple outputs and you want lazy evaluation.</p>
<pre><code class="lang-perl">1..3 |> flat_maps { ($_, $_ * 10) } |> e p
# 1 10 2 20 3 30
@nested |> flat_maps { @$_ } |> e p # flatten array-of-arrays
</code></pre>
</article>
<article class="doc-entry" id="doc-flatten-deep">
<h3><a class="doc-anchor" href="#doc-flatten-deep">#</a> <code>flatten_deep</code></h3>
<p><code>flatten_deep</code> — collection more builtin.</p>
<pre><code class="lang-perl">my $result = flatten_deep $x
# or in a pipeline:
@list |> map flatten_deep |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-flatten-once">
<h3><a class="doc-anchor" href="#doc-flatten-once">#</a> <code>flatten_once</code></h3>
<p><code>flatten_once</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = flatten_once $x
# or in a pipeline:
@list |> map flatten_once |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fldr">
<h3><a class="doc-anchor" href="#doc-fldr">#</a> <code>fldr</code></h3>
<p><code>fldr</code> — rust iterator methods builtin. Alias for <code>fold_right</code>.</p>
<pre><code class="lang-perl">my $result = fldr $x
# or in a pipeline:
@list |> map fldr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-flip-args">
<h3><a class="doc-anchor" href="#doc-flip-args">#</a> <code>flip_args</code></h3>
<p><code>flip_args</code> — functional primitives builtin.</p>
<pre><code class="lang-perl">my $result = flip_args $x
# or in a pipeline:
@list |> map flip_args |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-float-bits">
<h3><a class="doc-anchor" href="#doc-float-bits">#</a> <code>float_bits</code></h3>
<p><code>float_bits</code> — math functions builtin.</p>
<pre><code class="lang-perl">my $result = float_bits $x
# or in a pipeline:
@list |> map float_bits |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-floor">
<h3><a class="doc-anchor" href="#doc-floor">#</a> <code>floor</code></h3>
<p><code>floor</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = floor $x
# or in a pipeline:
@list |> map floor |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-floor-div">
<h3><a class="doc-anchor" href="#doc-floor-div">#</a> <code>floor_div</code></h3>
<p><code>floor_div</code> — trig / math (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = floor_div $x
# or in a pipeline:
@list |> map floor_div |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-floor-div-op">
<h3><a class="doc-anchor" href="#doc-floor-div-op">#</a> <code>floor_div_op</code></h3>
<p><code>floor_div_op</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = floor_div_op $x
# or in a pipeline:
@list |> map floor_div_op |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-floor-each">
<h3><a class="doc-anchor" href="#doc-floor-each">#</a> <code>floor_each</code></h3>
<p><code>floor_each</code> — trivial numeric helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = floor_each $x
# or in a pipeline:
@list |> map floor_each |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-floor-mod">
<h3><a class="doc-anchor" href="#doc-floor-mod">#</a> <code>floor_mod</code></h3>
<p><code>floor_mod</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = floor_mod $x
# or in a pipeline:
@list |> map floor_mod |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fltd">
<h3><a class="doc-anchor" href="#doc-fltd">#</a> <code>fltd</code></h3>
<p><code>fltd</code> — javascript array/object methods builtin. Alias for <code>flat_depth</code>.</p>
<pre><code class="lang-perl">my $result = fltd $x
# or in a pipeline:
@list |> map fltd |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-flti">
<h3><a class="doc-anchor" href="#doc-flti">#</a> <code>flti</code></h3>
<p><code>flti</code> — go/general functional utilities builtin. Alias for <code>filter_indexed</code>.</p>
<pre><code class="lang-perl">my $result = flti $x
# or in a pipeline:
@list |> map flti |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fltm">
<h3><a class="doc-anchor" href="#doc-fltm">#</a> <code>fltm</code></h3>
<p><code>fltm</code> — rust iterator methods builtin. Alias for <code>filter_map</code>.</p>
<pre><code class="lang-perl">my $result = fltm $x
# or in a pipeline:
@list |> map fltm |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fma">
<h3><a class="doc-anchor" href="#doc-fma">#</a> <code>fma</code></h3>
<p><code>fma</code> — math functions builtin.</p>
<pre><code class="lang-perl">my $result = fma $x
# or in a pipeline:
@list |> map fma |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fmadd">
<h3><a class="doc-anchor" href="#doc-fmadd">#</a> <code>fmadd</code></h3>
<p><code>fmadd</code> — extended stdlib builtin. Alias for <code>fused_mul_add</code>.</p>
<pre><code class="lang-perl">my $result = fmadd $x
# or in a pipeline:
@list |> map fmadd |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fmf">
<h3><a class="doc-anchor" href="#doc-fmf">#</a> <code>fmf</code></h3>
<p><code>fmf</code> — python/ruby stdlib builtin. Alias for <code>flat_map_fn</code>.</p>
<pre><code class="lang-perl">my $result = fmf $x
# or in a pipeline:
@list |> map fmf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fmod">
<h3><a class="doc-anchor" href="#doc-fmod">#</a> <code>fmod</code></h3>
<p><code>fmod</code> — extended stdlib builtin. Alias for <code>floor_mod</code>.</p>
<pre><code class="lang-perl">my $result = fmod $x
# or in a pipeline:
@list |> map fmod |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fndalli">
<h3><a class="doc-anchor" href="#doc-fndalli">#</a> <code>fndalli</code></h3>
<p><code>fndalli</code> — extended stdlib builtin. Alias for <code>find_all_indices</code>.</p>
<pre><code class="lang-perl">my $result = fndalli $x
# or in a pipeline:
@list |> map fndalli |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fndidxs">
<h3><a class="doc-anchor" href="#doc-fndidxs">#</a> <code>fndidxs</code></h3>
<p><code>fndidxs</code> — additional missing stdlib functions builtin. Alias for <code>find_indices</code>.</p>
<pre><code class="lang-perl">my $result = fndidxs $x
# or in a pipeline:
@list |> map fndidxs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fndl">
<h3><a class="doc-anchor" href="#doc-fndl">#</a> <code>fndl</code></h3>
<p><code>fndl</code> — javascript array/object methods builtin. Alias for <code>find_last</code>.</p>
<pre><code class="lang-perl">my $result = fndl $x
# or in a pipeline:
@list |> map fndl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fndli">
<h3><a class="doc-anchor" href="#doc-fndli">#</a> <code>fndli</code></h3>
<p><code>fndli</code> — javascript array/object methods builtin. Alias for <code>find_last_index</code>.</p>
<pre><code class="lang-perl">my $result = fndli $x
# or in a pipeline:
@list |> map fndli |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fndm">
<h3><a class="doc-anchor" href="#doc-fndm">#</a> <code>fndm</code></h3>
<p><code>fndm</code> — rust iterator methods builtin. Alias for <code>find_map</code>.</p>
<pre><code class="lang-perl">my $result = fndm $x
# or in a pipeline:
@list |> map fndm |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fne">
<h3><a class="doc-anchor" href="#doc-fne">#</a> <code>fne</code></h3>
<p><code>fne</code> — algebraic match builtin. Alias for <code>fnext</code>.</p>
<pre><code class="lang-perl">my $result = fne $x
# or in a pipeline:
@list |> map fne |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fnext">
<h3><a class="doc-anchor" href="#doc-fnext">#</a> <code>fnext</code></h3>
<p><code>fnext</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = fnext $x
# or in a pipeline:
@list |> map fnext |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fnv1a">
<h3><a class="doc-anchor" href="#doc-fnv1a">#</a> <code>fnv1a</code></h3>
<p><code>fnv1a</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = fnv1a $x
# or in a pipeline:
@list |> map fnv1a |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fold-left">
<h3><a class="doc-anchor" href="#doc-fold-left">#</a> <code>fold_left</code></h3>
<p><code>fold_left</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = fold_left $x
# or in a pipeline:
@list |> map fold_left |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fold-right">
<h3><a class="doc-anchor" href="#doc-fold-right">#</a> <code>fold_right</code></h3>
<p><code>fold_right</code> — rust iterator methods builtin.</p>
<pre><code class="lang-perl">my $result = fold_right $x
# or in a pipeline:
@list |> map fold_right |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-force-mass-acc">
<h3><a class="doc-anchor" href="#doc-force-mass-acc">#</a> <code>force_mass_acc</code></h3>
<p><code>force_mass_acc</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = force_mass_acc $x
# or in a pipeline:
@list |> map force_mass_acc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-format-bytes">
<h3><a class="doc-anchor" href="#doc-format-bytes">#</a> <code>format_bytes</code></h3>
<p><code>format_bytes</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = format_bytes $x
# or in a pipeline:
@list |> map format_bytes |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-format-duration">
<h3><a class="doc-anchor" href="#doc-format-duration">#</a> <code>format_duration</code></h3>
<p><code>format_duration</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = format_duration $x
# or in a pipeline:
@list |> map format_duration |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-format-number">
<h3><a class="doc-anchor" href="#doc-format-number">#</a> <code>format_number</code></h3>
<p><code>format_number</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = format_number $x
# or in a pipeline:
@list |> map format_number |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-format-percent">
<h3><a class="doc-anchor" href="#doc-format-percent">#</a> <code>format_percent</code></h3>
<p><code>format_percent</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = format_percent $x
# or in a pipeline:
@list |> map format_percent |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fr">
<h3><a class="doc-anchor" href="#doc-fr">#</a> <code>fr</code></h3>
<p><code>fr</code> — filesystem extensions builtin.</p>
<pre><code class="lang-perl">my $result = fr $x
# or in a pipeline:
@list |> map fr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-frac-part">
<h3><a class="doc-anchor" href="#doc-frac-part">#</a> <code>frac_part</code></h3>
<p><code>frac_part</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = frac_part $x
# or in a pipeline:
@list |> map frac_part |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fracp">
<h3><a class="doc-anchor" href="#doc-fracp">#</a> <code>fracp</code></h3>
<p><code>fracp</code> — extended stdlib builtin. Alias for <code>frac_part</code>.</p>
<pre><code class="lang-perl">my $result = fracp $x
# or in a pipeline:
@list |> map fracp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-freq-wavelength">
<h3><a class="doc-anchor" href="#doc-freq-wavelength">#</a> <code>freq_wavelength</code></h3>
<p><code>freq_wavelength</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = freq_wavelength $x
# or in a pipeline:
@list |> map freq_wavelength |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-from-base">
<h3><a class="doc-anchor" href="#doc-from-base">#</a> <code>from_base</code></h3>
<p><code>from_base</code> — base conversion builtin.</p>
<pre><code class="lang-perl">my $result = from_base $x
# or in a pipeline:
@list |> map from_base |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-from-bin">
<h3><a class="doc-anchor" href="#doc-from-bin">#</a> <code>from_bin</code></h3>
<p><code>from_bin</code> — base conversion builtin.</p>
<pre><code class="lang-perl">my $result = from_bin $x
# or in a pipeline:
@list |> map from_bin |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-from-code-point">
<h3><a class="doc-anchor" href="#doc-from-code-point">#</a> <code>from_code_point</code></h3>
<p><code>from_code_point</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = from_code_point $x
# or in a pipeline:
@list |> map from_code_point |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-from-csv-line">
<h3><a class="doc-anchor" href="#doc-from-csv-line">#</a> <code>from_csv_line</code></h3>
<p><code>from_csv_line</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = from_csv_line $x
# or in a pipeline:
@list |> map from_csv_line |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-from-digits">
<h3><a class="doc-anchor" href="#doc-from-digits">#</a> <code>from_digits</code></h3>
<p><code>from_digits</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = from_digits $x
# or in a pipeline:
@list |> map from_digits |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-from-hex">
<h3><a class="doc-anchor" href="#doc-from-hex">#</a> <code>from_hex</code></h3>
<p><code>from_hex</code> — base conversion builtin.</p>
<pre><code class="lang-perl">my $result = from_hex $x
# or in a pipeline:
@list |> map from_hex |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-from-oct">
<h3><a class="doc-anchor" href="#doc-from-oct">#</a> <code>from_oct</code></h3>
<p><code>from_oct</code> — base conversion builtin.</p>
<pre><code class="lang-perl">my $result = from_oct $x
# or in a pipeline:
@list |> map from_oct |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-from-pairs">
<h3><a class="doc-anchor" href="#doc-from-pairs">#</a> <code>from_pairs</code></h3>
<p><code>from_pairs</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = from_pairs $x
# or in a pipeline:
@list |> map from_pairs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-frustum-volume">
<h3><a class="doc-anchor" href="#doc-frustum-volume">#</a> <code>frustum_volume</code></h3>
<p><code>frustum_volume($r1, $r2, $h)</code> — computes the volume of a conical frustum (truncated cone) with base radii r1 and r2 and height h.</p>
<pre><code class="lang-perl">p frustum_volume(5, 3, 10) # ~513
</code></pre>
</article>
<article class="doc-entry" id="doc-frustvol">
<h3><a class="doc-anchor" href="#doc-frustvol">#</a> <code>frustvol</code></h3>
<p><code>frustvol</code> — geometry (extended) builtin. Alias for <code>frustum_volume</code>.</p>
<pre><code class="lang-perl">my $result = frustvol $x
# or in a pipeline:
@list |> map frustvol |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fsize">
<h3><a class="doc-anchor" href="#doc-fsize">#</a> <code>fsize</code></h3>
<p><code>fsize</code> — file stat / path builtin. Alias for <code>file_size</code>.</p>
<pre><code class="lang-perl">my $result = fsize $x
# or in a pipeline:
@list |> map fsize |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fst">
<h3><a class="doc-anchor" href="#doc-fst">#</a> <code>fst</code></h3>
<p><code>fst</code> — internal builtin. Alias for <code>__stryke_rust_compile</code>.</p>
<pre><code class="lang-perl">my $result = fst $x
# or in a pipeline:
@list |> map fst |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ft">
<h3><a class="doc-anchor" href="#doc-ft">#</a> <code>ft</code></h3>
<p><code>ft</code> — data / network builtin. Alias for <code>fetch</code>.</p>
<pre><code class="lang-perl">my $result = ft $x
# or in a pipeline:
@list |> map ft |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fta">
<h3><a class="doc-anchor" href="#doc-fta">#</a> <code>fta</code></h3>
<p><code>fta</code> — data / network builtin. Alias for <code>fetch_async</code>.</p>
<pre><code class="lang-perl">my $result = fta $x
# or in a pipeline:
@list |> map fta |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ftaj">
<h3><a class="doc-anchor" href="#doc-ftaj">#</a> <code>ftaj</code></h3>
<p><code>ftaj</code> — data / network builtin. Alias for <code>fetch_async_json</code>.</p>
<pre><code class="lang-perl">my $result = ftaj $x
# or in a pipeline:
@list |> map ftaj |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ftj">
<h3><a class="doc-anchor" href="#doc-ftj">#</a> <code>ftj</code></h3>
<p><code>ftj</code> — data / network builtin. Alias for <code>fetch_json</code>.</p>
<pre><code class="lang-perl">my $result = ftj $x
# or in a pipeline:
@list |> map ftj |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fused-mul-add">
<h3><a class="doc-anchor" href="#doc-fused-mul-add">#</a> <code>fused_mul_add</code></h3>
<p><code>fused_mul_add</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = fused_mul_add $x
# or in a pipeline:
@list |> map fused_mul_add |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-future-value">
<h3><a class="doc-anchor" href="#doc-future-value">#</a> <code>future_value</code></h3>
<p><code>future_value</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = future_value $x
# or in a pipeline:
@list |> map future_value |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-fv">
<h3><a class="doc-anchor" href="#doc-fv">#</a> <code>fv</code></h3>
<p><code>fv</code> — python/ruby stdlib builtin. Alias for <code>fetch_val</code>.</p>
<pre><code class="lang-perl">my $result = fv $x
# or in a pipeline:
@list |> map fv |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-g-to-oz">
<h3><a class="doc-anchor" href="#doc-g-to-oz">#</a> <code>g_to_oz</code></h3>
<p><code>g_to_oz</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = g_to_oz $input
</code></pre>
</article>
<article class="doc-entry" id="doc-gallons-to-liters">
<h3><a class="doc-anchor" href="#doc-gallons-to-liters">#</a> <code>gallons_to_liters</code></h3>
<p><code>gallons_to_liters</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = gallons_to_liters $input
</code></pre>
</article>
<article class="doc-entry" id="doc-game-of-life-step">
<h3><a class="doc-anchor" href="#doc-game-of-life-step">#</a> <code>game_of_life_step</code></h3>
<p><code>game_of_life_step</code> — algorithms / puzzles builtin.</p>
<pre><code class="lang-perl">my $result = game_of_life_step $x
# or in a pipeline:
@list |> map game_of_life_step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gamma-approx">
<h3><a class="doc-anchor" href="#doc-gamma-approx">#</a> <code>gamma_approx</code></h3>
<p><code>gamma_approx($z)</code> — Gamma function Γ(z) using Lanczos approximation. Extends factorial: Γ(n) = (n-1)!</p>
<pre><code class="lang-perl">p gamma(5) # 24 (same as 4!)
p gamma(0.5) # ~1.772 (√π)
</code></pre>
</article>
<article class="doc-entry" id="doc-gamma-pdf">
<h3><a class="doc-anchor" href="#doc-gamma-pdf">#</a> <code>gamma_pdf</code></h3>
<p><code>gamma_pdf</code> (alias <code>gammapdf</code>) evaluates the Gamma distribution PDF at x with shape k and scale theta.</p>
<pre><code class="lang-perl">p gammapdf(2.0, 2, 1) # Gamma(2,1) at x=2
</code></pre>
</article>
<article class="doc-entry" id="doc-gas-constant">
<h3><a class="doc-anchor" href="#doc-gas-constant">#</a> <code>gas_constant</code></h3>
<p><code>gas_constant</code> (alias <code>rgas</code>) — R ≈ 8.314 J/(mol⋅K). Universal gas constant.</p>
<pre><code class="lang-perl">p rgas # 8.314462618
</code></pre>
</article>
<article class="doc-entry" id="doc-gasp">
<h3><a class="doc-anchor" href="#doc-gasp">#</a> <code>gasp</code></h3>
<p><code>ideal_gas_pressure($n, $V, $T)</code> (alias <code>gasp</code>) — pressure P = nRT/V. n moles, V volume (m³), T temperature (K).</p>
<pre><code class="lang-perl">p gasp(1, 0.0224, 273.15) # ~101325 Pa (1 mol at STP)
</code></pre>
</article>
<article class="doc-entry" id="doc-gasv">
<h3><a class="doc-anchor" href="#doc-gasv">#</a> <code>gasv</code></h3>
<p><code>gasv</code> — physics formulas builtin. Alias for <code>ideal_gas_volume</code>.</p>
<pre><code class="lang-perl">my $result = gasv $x
# or in a pipeline:
@list |> map gasv |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gb-to-bytes">
<h3><a class="doc-anchor" href="#doc-gb-to-bytes">#</a> <code>gb_to_bytes</code></h3>
<p><code>gb_to_bytes</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = gb_to_bytes $input
</code></pre>
</article>
<article class="doc-entry" id="doc-gbf">
<h3><a class="doc-anchor" href="#doc-gbf">#</a> <code>gbf</code></h3>
<p><code>gbf</code> — go/general functional utilities builtin. Alias for <code>group_by_fn</code>.</p>
<pre><code class="lang-perl">my $result = gbf $x
# or in a pipeline:
@list |> map gbf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gbi">
<h3><a class="doc-anchor" href="#doc-gbi">#</a> <code>gbi</code></h3>
<p><code>gbi</code> — python/ruby stdlib builtin. Alias for <code>groupby_iter</code>.</p>
<pre><code class="lang-perl">my $result = gbi $x
# or in a pipeline:
@list |> map gbi |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gcby">
<h3><a class="doc-anchor" href="#doc-gcby">#</a> <code>gcby</code></h3>
<p><code>gcby</code> — matrix operations (uncategorized batch) builtin. Alias for <code>group_consecutive_by</code>.</p>
<pre><code class="lang-perl">my $result = gcby $x
# or in a pipeline:
@list |> map gcby |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gcd">
<h3><a class="doc-anchor" href="#doc-gcd">#</a> <code>gcd</code></h3>
<p><code>gcd</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = gcd $x
# or in a pipeline:
@list |> map gcd |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gconst">
<h3><a class="doc-anchor" href="#doc-gconst">#</a> <code>gconst</code></h3>
<p><code>gconst</code> — constants builtin. Alias for <code>gravitational_constant</code>.</p>
<pre><code class="lang-perl">my $result = gconst $x
# or in a pipeline:
@list |> map gconst |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gelu">
<h3><a class="doc-anchor" href="#doc-gelu">#</a> <code>gelu</code></h3>
<p><code>gelu</code> applies the Gaussian Error Linear Unit, used in BERT/GPT transformers.</p>
<pre><code class="lang-perl">p gelu(1) # 0.8412
p gelu(-1) # -0.1588
</code></pre>
</article>
<article class="doc-entry" id="doc-geometric-mean">
<h3><a class="doc-anchor" href="#doc-geometric-mean">#</a> <code>geometric_mean</code></h3>
<p><code>geometric_mean</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = geometric_mean $x
# or in a pipeline:
@list |> map geometric_mean |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-geometric-series">
<h3><a class="doc-anchor" href="#doc-geometric-series">#</a> <code>geometric_series</code></h3>
<p><code>geometric_series($a1, $r, $n)</code> (alias <code>geomser</code>) — sum of n terms of geometric sequence. Formula: a1×(1-rⁿ)/(1-r). If r=1, returns a1×n.</p>
<pre><code class="lang-perl">p geomser(1, 2, 10) # 1023 (1+2+4+...+512)
p geomser(1, 0.5, 10) # ~1.998 (converging to 2)
</code></pre>
</article>
<article class="doc-entry" id="doc-get-in">
<h3><a class="doc-anchor" href="#doc-get-in">#</a> <code>get_in</code></h3>
<p><code>get_in</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = get_in $x
# or in a pipeline:
@list |> map get_in |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gethostent">
<h3><a class="doc-anchor" href="#doc-gethostent">#</a> <code>gethostent</code></h3>
<p><code>gethostent</code> — posix metadata builtin.</p>
<pre><code class="lang-perl">my $result = gethostent $x
# or in a pipeline:
@list |> map gethostent |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-getnetbyname">
<h3><a class="doc-anchor" href="#doc-getnetbyname">#</a> <code>getnetbyname</code></h3>
<p><code>getnetbyname</code> — posix metadata builtin.</p>
<pre><code class="lang-perl">my $result = getnetbyname $x
# or in a pipeline:
@list |> map getnetbyname |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-getnetent">
<h3><a class="doc-anchor" href="#doc-getnetent">#</a> <code>getnetent</code></h3>
<p><code>getnetent</code> — posix metadata builtin.</p>
<pre><code class="lang-perl">my $result = getnetent $x
# or in a pipeline:
@list |> map getnetent |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-getprotoent">
<h3><a class="doc-anchor" href="#doc-getprotoent">#</a> <code>getprotoent</code></h3>
<p><code>getprotoent</code> — posix metadata builtin.</p>
<pre><code class="lang-perl">my $result = getprotoent $x
# or in a pipeline:
@list |> map getprotoent |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-getservent">
<h3><a class="doc-anchor" href="#doc-getservent">#</a> <code>getservent</code></h3>
<p><code>getservent</code> — posix metadata builtin.</p>
<pre><code class="lang-perl">my $result = getservent $x
# or in a pipeline:
@list |> map getservent |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gforce">
<h3><a class="doc-anchor" href="#doc-gforce">#</a> <code>gforce</code></h3>
<p><code>gravitational_force($m1, $m2, $r)</code> (alias <code>gforce</code>) — Newton's law of gravitation: F = Gm₁m₂/r².</p>
<pre><code class="lang-perl">p gforce(5.972e24, 1000, 6.371e6) # ~9820 N (1 ton at Earth surface)
</code></pre>
</article>
<article class="doc-entry" id="doc-gid">
<h3><a class="doc-anchor" href="#doc-gid">#</a> <code>gid</code></h3>
<p><code>gid</code> — system introspection builtin.</p>
<pre><code class="lang-perl">my $result = gid $x
# or in a pipeline:
@list |> map gid |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gin">
<h3><a class="doc-anchor" href="#doc-gin">#</a> <code>gin</code></h3>
<p><code>gin</code> — algebraic match builtin. Alias for <code>get_in</code>.</p>
<pre><code class="lang-perl">my $result = gin $x
# or in a pipeline:
@list |> map gin |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gini">
<h3><a class="doc-anchor" href="#doc-gini">#</a> <code>gini</code></h3>
<p><code>gini(@data)</code> (alias <code>gini_coefficient</code>) — computes the Gini coefficient measuring inequality in a distribution. Returns a value from 0 (perfect equality) to 1 (perfect inequality). Commonly used for income distribution analysis.</p>
<pre><code class="lang-perl">p gini(1, 1, 1, 1) # 0 (perfect equality)
p gini(0, 0, 0, 100) # ~0.75 (high inequality)
</code></pre>
</article>
<article class="doc-entry" id="doc-glaisher">
<h3><a class="doc-anchor" href="#doc-glaisher">#</a> <code>glaisher</code></h3>
<p><code>glaisher</code> — math constants builtin. Alias for <code>glaisher_constant</code>.</p>
<pre><code class="lang-perl">my $result = glaisher $x
# or in a pipeline:
@list |> map glaisher |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-glaisher-constant">
<h3><a class="doc-anchor" href="#doc-glaisher-constant">#</a> <code>glaisher_constant</code></h3>
<p><code>glaisher_constant</code> — math constants builtin.</p>
<pre><code class="lang-perl">my $result = glaisher_constant $x
# or in a pipeline:
@list |> map glaisher_constant |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-glob-to-regex">
<h3><a class="doc-anchor" href="#doc-glob-to-regex">#</a> <code>glob_to_regex</code></h3>
<p><code>glob_to_regex</code> — more regex builtin.</p>
<pre><code class="lang-perl">my $result = glob_to_regex $input
</code></pre>
</article>
<article class="doc-entry" id="doc-goertzel">
<h3><a class="doc-anchor" href="#doc-goertzel">#</a> <code>goertzel</code></h3>
<p><code>goertzel</code> computes the magnitude of a single DFT frequency bin using the Goertzel algorithm. Much faster than full FFT when you need one frequency.</p>
<pre><code class="lang-perl">my $mag = goertzel(\@signal, 440, 44100) # 440 Hz component
</code></pre>
</article>
<article class="doc-entry" id="doc-goldb">
<h3><a class="doc-anchor" href="#doc-goldb">#</a> <code>goldb</code></h3>
<p><code>goldb</code> — math / numeric (uncategorized batch) builtin. Alias for <code>goldbach</code>.</p>
<pre><code class="lang-perl">my $result = goldb $x
# or in a pipeline:
@list |> map goldb |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-goldbach">
<h3><a class="doc-anchor" href="#doc-goldbach">#</a> <code>goldbach</code></h3>
<p><code>goldbach</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = goldbach $x
# or in a pipeline:
@list |> map goldbach |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-golden">
<h3><a class="doc-anchor" href="#doc-golden">#</a> <code>golden</code></h3>
<p><code>golden_section</code> (aliases <code>golden</code>, <code>gss</code>) finds the minimum of f on [a,b] via golden-section search.</p>
<pre><code class="lang-perl">my $xmin = golden(fn { ($_[0]-3)**2 }, 0, 10) # 3.0
</code></pre>
</article>
<article class="doc-entry" id="doc-golden-ratio">
<h3><a class="doc-anchor" href="#doc-golden-ratio">#</a> <code>golden_ratio</code></h3>
<p><code>golden_ratio</code> (alias <code>phi</code>) — φ = (1+√5)/2 ≈ 1.618. The golden ratio, appears throughout nature and art.</p>
<pre><code class="lang-perl">p phi # 1.618033988749895
# Fibonacci limit: fib(n)/fib(n-1) → φ
</code></pre>
</article>
<article class="doc-entry" id="doc-golstep">
<h3><a class="doc-anchor" href="#doc-golstep">#</a> <code>golstep</code></h3>
<p><code>golstep</code> — algorithms / puzzles builtin. Alias for <code>game_of_life_step</code>.</p>
<pre><code class="lang-perl">my $result = golstep $x
# or in a pipeline:
@list |> map golstep |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-goto">
<h3><a class="doc-anchor" href="#doc-goto">#</a> <code>goto</code></h3>
<p><code>goto</code> — control flow builtin.</p>
<pre><code class="lang-perl">my $result = goto $x
# or in a pipeline:
@list |> map goto |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gravitational-constant">
<h3><a class="doc-anchor" href="#doc-gravitational-constant">#</a> <code>gravitational_constant</code></h3>
<p><code>gravitational_constant</code> — constants builtin.</p>
<pre><code class="lang-perl">my $result = gravitational_constant $x
# or in a pipeline:
@list |> map gravitational_constant |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gravity">
<h3><a class="doc-anchor" href="#doc-gravity">#</a> <code>gravity</code></h3>
<p><code>gravity</code> — math / physics constants builtin.</p>
<pre><code class="lang-perl">my $result = gravity $x
# or in a pipeline:
@list |> map gravity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gray">
<h3><a class="doc-anchor" href="#doc-gray">#</a> <code>gray</code></h3>
<p><code>gray</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = gray $x
# or in a pipeline:
@list |> map gray |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gray2b">
<h3><a class="doc-anchor" href="#doc-gray2b">#</a> <code>gray2b</code></h3>
<p><code>gray2b</code> — base / gray code builtin. Alias for <code>gray_to_binary</code>.</p>
<pre><code class="lang-perl">my $result = gray2b $x
# or in a pipeline:
@list |> map gray2b |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gray-code-sequence">
<h3><a class="doc-anchor" href="#doc-gray-code-sequence">#</a> <code>gray_code_sequence</code></h3>
<p><code>gray_code_sequence</code> — base / gray code builtin.</p>
<pre><code class="lang-perl">my $result = gray_code_sequence $x
# or in a pipeline:
@list |> map gray_code_sequence |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gray-to-binary">
<h3><a class="doc-anchor" href="#doc-gray-to-binary">#</a> <code>gray_to_binary</code></h3>
<p><code>gray_to_binary</code> — base / gray code builtin.</p>
<pre><code class="lang-perl">my $result = gray_to_binary $input
</code></pre>
</article>
<article class="doc-entry" id="doc-grayseq">
<h3><a class="doc-anchor" href="#doc-grayseq">#</a> <code>grayseq</code></h3>
<p><code>grayseq</code> — base / gray code builtin. Alias for <code>gray_code_sequence</code>.</p>
<pre><code class="lang-perl">my $result = grayseq $x
# or in a pipeline:
@list |> map grayseq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-green">
<h3><a class="doc-anchor" href="#doc-green">#</a> <code>green</code></h3>
<p><code>green</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = green $x
# or in a pipeline:
@list |> map green |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-green-bold">
<h3><a class="doc-anchor" href="#doc-green-bold">#</a> <code>green_bold</code></h3>
<p><code>green_bold</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = green_bold $x
# or in a pipeline:
@list |> map green_bold |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-grey">
<h3><a class="doc-anchor" href="#doc-grey">#</a> <code>grey</code></h3>
<p><code>grey</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = grey $x
# or in a pipeline:
@list |> map grey |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-group-by">
<h3><a class="doc-anchor" href="#doc-group-by">#</a> <code>group_by</code></h3>
<p><code>group_by</code> — functional / iterator builtin.</p>
<pre><code class="lang-perl">my $result = group_by $x
# or in a pipeline:
@list |> map group_by |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-group-by-fn">
<h3><a class="doc-anchor" href="#doc-group-by-fn">#</a> <code>group_by_fn</code></h3>
<p><code>group_by_fn</code> — go/general functional utilities builtin.</p>
<pre><code class="lang-perl">my $result = group_by_fn $x
# or in a pipeline:
@list |> map group_by_fn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-group-by-size">
<h3><a class="doc-anchor" href="#doc-group-by-size">#</a> <code>group_by_size</code></h3>
<p><code>group_by_size</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = group_by_size $x
# or in a pipeline:
@list |> map group_by_size |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-group-consecutive">
<h3><a class="doc-anchor" href="#doc-group-consecutive">#</a> <code>group_consecutive</code></h3>
<p><code>group_consecutive</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = group_consecutive $x
# or in a pipeline:
@list |> map group_consecutive |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-group-consecutive-by">
<h3><a class="doc-anchor" href="#doc-group-consecutive-by">#</a> <code>group_consecutive_by</code></h3>
<p><code>group_consecutive_by</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = group_consecutive_by $x
# or in a pipeline:
@list |> map group_consecutive_by |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-group-number">
<h3><a class="doc-anchor" href="#doc-group-number">#</a> <code>group_number</code></h3>
<p><code>group_number</code> — file stat / path builtin. Alias for <code>format_number</code>.</p>
<pre><code class="lang-perl">my $result = group_number $x
# or in a pipeline:
@list |> map group_number |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-group-of-n">
<h3><a class="doc-anchor" href="#doc-group-of-n">#</a> <code>group_of_n</code></h3>
<p><code>group_of_n</code> — collection (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = group_of_n $x
# or in a pipeline:
@list |> map group_of_n |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-group-runs">
<h3><a class="doc-anchor" href="#doc-group-runs">#</a> <code>group_runs</code></h3>
<p><code>group_runs</code> — haskell list functions builtin.</p>
<pre><code class="lang-perl">my $result = group_runs $x
# or in a pipeline:
@list |> map group_runs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-groupby-iter">
<h3><a class="doc-anchor" href="#doc-groupby-iter">#</a> <code>groupby_iter</code></h3>
<p><code>groupby_iter</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = groupby_iter $x
# or in a pipeline:
@list |> map groupby_iter |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gruns">
<h3><a class="doc-anchor" href="#doc-gruns">#</a> <code>gruns</code></h3>
<p><code>gruns</code> — haskell list functions builtin. Alias for <code>group_runs</code>.</p>
<pre><code class="lang-perl">my $result = gruns $x
# or in a pipeline:
@list |> map gruns |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-gz">
<h3><a class="doc-anchor" href="#doc-gz">#</a> <code>gz</code></h3>
<p><code>gz</code> — crypto / encoding builtin. Alias for <code>gzip</code>.</p>
<pre><code class="lang-perl">my $result = gz $x
# or in a pipeline:
@list |> map gz |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-h0">
<h3><a class="doc-anchor" href="#doc-h0">#</a> <code>h0</code></h3>
<p><code>h0</code> — physics constants builtin. Alias for <code>hubble_constant</code>.</p>
<pre><code class="lang-perl">my $result = h0 $x
# or in a pipeline:
@list |> map h0 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-half">
<h3><a class="doc-anchor" href="#doc-half">#</a> <code>half</code></h3>
<p><code>half</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = half $x
# or in a pipeline:
@list |> map half |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-half-each">
<h3><a class="doc-anchor" href="#doc-half-each">#</a> <code>half_each</code></h3>
<p><code>half_each</code> — trivial numeric helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = half_each $x
# or in a pipeline:
@list |> map half_each |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hamdist">
<h3><a class="doc-anchor" href="#doc-hamdist">#</a> <code>hamdist</code></h3>
<p><code>hamdist</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = hamdist $x
# or in a pipeline:
@list |> map hamdist |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hamming">
<h3><a class="doc-anchor" href="#doc-hamming">#</a> <code>hamming</code></h3>
<p><code>window_hamming($n)</code> (alias <code>hamming</code>) — generates a Hamming window of length n. Similar to Hann but with slightly different coefficients, optimized for speech processing.</p>
<pre><code class="lang-perl">my $w = hamming(1024)
</code></pre>
</article>
<article class="doc-entry" id="doc-hamming-distance">
<h3><a class="doc-anchor" href="#doc-hamming-distance">#</a> <code>hamming_distance</code></h3>
<p><code>hamming_distance</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = hamming_distance $x
# or in a pipeline:
@list |> map hamming_distance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hann">
<h3><a class="doc-anchor" href="#doc-hann">#</a> <code>hann</code></h3>
<p><code>window_hann($n)</code> (alias <code>hann</code>) — generates a Hann (raised cosine) window of length n. Common window function for spectral analysis that reduces spectral leakage.</p>
<pre><code class="lang-perl">my $w = hann(1024)
</code></pre>
</article>
<article class="doc-entry" id="doc-hanoi">
<h3><a class="doc-anchor" href="#doc-hanoi">#</a> <code>hanoi</code></h3>
<p><code>hanoi</code> — algorithms / puzzles builtin. Alias for <code>tower_of_hanoi</code>.</p>
<pre><code class="lang-perl">my $result = hanoi $x
# or in a pipeline:
@list |> map hanoi |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hard-sigmoid">
<h3><a class="doc-anchor" href="#doc-hard-sigmoid">#</a> <code>hard_sigmoid</code></h3>
<p><code>hard_sigmoid</code> — ml activation functions builtin.</p>
<pre><code class="lang-perl">my $result = hard_sigmoid $x
# or in a pipeline:
@list |> map hard_sigmoid |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hard-swish">
<h3><a class="doc-anchor" href="#doc-hard-swish">#</a> <code>hard_swish</code></h3>
<p><code>hard_swish</code> — ml activation functions builtin.</p>
<pre><code class="lang-perl">my $result = hard_swish $x
# or in a pipeline:
@list |> map hard_swish |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hardsigmoid">
<h3><a class="doc-anchor" href="#doc-hardsigmoid">#</a> <code>hardsigmoid</code></h3>
<p><code>hardsigmoid</code> — ml activation functions builtin. Alias for <code>hard_sigmoid</code>.</p>
<pre><code class="lang-perl">my $result = hardsigmoid $x
# or in a pipeline:
@list |> map hardsigmoid |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hardswish">
<h3><a class="doc-anchor" href="#doc-hardswish">#</a> <code>hardswish</code></h3>
<p><code>hardswish</code> — ml activation functions builtin. Alias for <code>hard_swish</code>.</p>
<pre><code class="lang-perl">my $result = hardswish $x
# or in a pipeline:
@list |> map hardswish |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-harmonic">
<h3><a class="doc-anchor" href="#doc-harmonic">#</a> <code>harmonic</code></h3>
<p><code>harmonic_number</code> (alias <code>harmonic</code>) computes the nth harmonic number H_n = 1 + 1/2 + 1/3 + ... + 1/n.</p>
<pre><code class="lang-perl">p harmonic(1) # 1.0
p harmonic(10) # 2.9290
p harmonic(100) # 5.1874
</code></pre>
</article>
<article class="doc-entry" id="doc-harmonic-mean">
<h3><a class="doc-anchor" href="#doc-harmonic-mean">#</a> <code>harmonic_mean</code></h3>
<p><code>harmonic_mean</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = harmonic_mean $x
# or in a pipeline:
@list |> map harmonic_mean |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-has-all-keys">
<h3><a class="doc-anchor" href="#doc-has-all-keys">#</a> <code>has_all_keys</code></h3>
<p><code>has_all_keys</code> — hash helpers builtin.</p>
<pre><code class="lang-perl">my $result = has_all_keys $x
# or in a pipeline:
@list |> map has_all_keys |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-has-any-key">
<h3><a class="doc-anchor" href="#doc-has-any-key">#</a> <code>has_any_key</code></h3>
<p><code>has_any_key</code> — hash helpers builtin.</p>
<pre><code class="lang-perl">my $result = has_any_key $x
# or in a pipeline:
@list |> map has_any_key |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-has-cycle-graph">
<h3><a class="doc-anchor" href="#doc-has-cycle-graph">#</a> <code>has_cycle_graph</code></h3>
<p><code>has_cycle_graph</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = has_cycle_graph $x
# or in a pipeline:
@list |> map has_cycle_graph |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-has-duplicates">
<h3><a class="doc-anchor" href="#doc-has-duplicates">#</a> <code>has_duplicates</code></h3>
<p><code>has_duplicates</code> — more list helpers builtin.</p>
<pre><code class="lang-perl">my $result = has_duplicates $x
# or in a pipeline:
@list |> map has_duplicates |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-has-key">
<h3><a class="doc-anchor" href="#doc-has-key">#</a> <code>has_key</code></h3>
<p><code>has_key</code> — hash helpers builtin.</p>
<pre><code class="lang-perl">my $result = has_key $x
# or in a pipeline:
@list |> map has_key |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-has-stderr-tty">
<h3><a class="doc-anchor" href="#doc-has-stderr-tty">#</a> <code>has_stderr_tty</code></h3>
<p><code>has_stderr_tty</code> — process / env builtin.</p>
<pre><code class="lang-perl">my $result = has_stderr_tty $x
# or in a pipeline:
@list |> map has_stderr_tty |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-has-stdin-tty">
<h3><a class="doc-anchor" href="#doc-has-stdin-tty">#</a> <code>has_stdin_tty</code></h3>
<p><code>has_stdin_tty</code> — process / env builtin.</p>
<pre><code class="lang-perl">my $result = has_stdin_tty $x
# or in a pipeline:
@list |> map has_stdin_tty |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-has-stdout-tty">
<h3><a class="doc-anchor" href="#doc-has-stdout-tty">#</a> <code>has_stdout_tty</code></h3>
<p><code>has_stdout_tty</code> — process / env builtin.</p>
<pre><code class="lang-perl">my $result = has_stdout_tty $x
# or in a pipeline:
@list |> map has_stdout_tty |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hascyc">
<h3><a class="doc-anchor" href="#doc-hascyc">#</a> <code>hascyc</code></h3>
<p><code>hascyc</code> — extended stdlib builtin. Alias for <code>has_cycle_graph</code>.</p>
<pre><code class="lang-perl">my $result = hascyc $x
# or in a pipeline:
@list |> map hascyc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hash-delete">
<h3><a class="doc-anchor" href="#doc-hash-delete">#</a> <code>hash_delete</code></h3>
<p><code>hash_delete</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = hash_delete $x
# or in a pipeline:
@list |> map hash_delete |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hash-eq">
<h3><a class="doc-anchor" href="#doc-hash-eq">#</a> <code>hash_eq</code></h3>
<p><code>hash_eq</code> — hash ops (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = hash_eq $x
# or in a pipeline:
@list |> map hash_eq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hash-filter-keys">
<h3><a class="doc-anchor" href="#doc-hash-filter-keys">#</a> <code>hash_filter_keys</code></h3>
<p><code>hash_filter_keys</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = hash_filter_keys $x
# or in a pipeline:
@list |> map hash_filter_keys |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hash-from-list">
<h3><a class="doc-anchor" href="#doc-hash-from-list">#</a> <code>hash_from_list</code></h3>
<p><code>hash_from_list</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = hash_from_list $x
# or in a pipeline:
@list |> map hash_from_list |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hash-from-pairs">
<h3><a class="doc-anchor" href="#doc-hash-from-pairs">#</a> <code>hash_from_pairs</code></h3>
<p><code>hash_from_pairs</code> — hash ops (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = hash_from_pairs $x
# or in a pipeline:
@list |> map hash_from_pairs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hash-insert">
<h3><a class="doc-anchor" href="#doc-hash-insert">#</a> <code>hash_insert</code></h3>
<p><code>hash_insert</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = hash_insert $x
# or in a pipeline:
@list |> map hash_insert |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hash-map-values">
<h3><a class="doc-anchor" href="#doc-hash-map-values">#</a> <code>hash_map_values</code></h3>
<p><code>hash_map_values</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = hash_map_values $x
# or in a pipeline:
@list |> map hash_map_values |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hash-merge-deep">
<h3><a class="doc-anchor" href="#doc-hash-merge-deep">#</a> <code>hash_merge_deep</code></h3>
<p><code>hash_merge_deep</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = hash_merge_deep $x
# or in a pipeline:
@list |> map hash_merge_deep |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hash-size">
<h3><a class="doc-anchor" href="#doc-hash-size">#</a> <code>hash_size</code></h3>
<p><code>hash_size</code> — hash ops (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = hash_size $x
# or in a pipeline:
@list |> map hash_size |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hash-to-list">
<h3><a class="doc-anchor" href="#doc-hash-to-list">#</a> <code>hash_to_list</code></h3>
<p><code>hash_to_list</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = hash_to_list $input
</code></pre>
</article>
<article class="doc-entry" id="doc-hash-update">
<h3><a class="doc-anchor" href="#doc-hash-update">#</a> <code>hash_update</code></h3>
<p><code>hash_update</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = hash_update $x
# or in a pipeline:
@list |> map hash_update |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hash-zip">
<h3><a class="doc-anchor" href="#doc-hash-zip">#</a> <code>hash_zip</code></h3>
<p><code>hash_zip</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = hash_zip $x
# or in a pipeline:
@list |> map hash_zip |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-havdist">
<h3><a class="doc-anchor" href="#doc-havdist">#</a> <code>havdist</code></h3>
<p><code>havdist</code> — geometry (extended) builtin. Alias for <code>haversine_distance</code>.</p>
<pre><code class="lang-perl">my $result = havdist $x
# or in a pipeline:
@list |> map havdist |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-haversine">
<h3><a class="doc-anchor" href="#doc-haversine">#</a> <code>haversine</code></h3>
<p><code>haversine_distance($lat1, $lon1, $lat2, $lon2)</code> (alias <code>haversine</code>) — computes the great-circle distance between two points on Earth given latitude/longitude in degrees. Returns distance in kilometers.</p>
<pre><code class="lang-perl"># NYC to LA
p haversine(40.7128, -74.0060, 34.0522, -118.2437)
# ~3940 km
</code></pre>
</article>
<article class="doc-entry" id="doc-hclust">
<h3><a class="doc-anchor" href="#doc-hclust">#</a> <code>hclust</code></h3>
<p><code>hclust</code> — hierarchical clustering (average linkage). Takes a distance matrix. Returns merge list [[i,j,height],...]. Like R's hclust().</p>
<pre><code class="lang-perl">my $merges = hclust(dist_mat([[0,0],[1,0],[10,10]]))
</code></pre>
</article>
<article class="doc-entry" id="doc-head-lines">
<h3><a class="doc-anchor" href="#doc-head-lines">#</a> <code>head_lines</code></h3>
<p><code>head_lines</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = head_lines $x
# or in a pipeline:
@list |> map head_lines |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-head-n">
<h3><a class="doc-anchor" href="#doc-head-n">#</a> <code>head_n</code></h3>
<p><code>head_n</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = head_n $x
# or in a pipeline:
@list |> map head_n |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-head-str">
<h3><a class="doc-anchor" href="#doc-head-str">#</a> <code>head_str</code></h3>
<p><code>head_str</code> — string (batch 2) builtin. Alias for <code>left_str</code>.</p>
<pre><code class="lang-perl">my $result = head_str $x
# or in a pipeline:
@list |> map head_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-heat-index">
<h3><a class="doc-anchor" href="#doc-heat-index">#</a> <code>heat_index</code></h3>
<p><code>heat_index</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = heat_index $x
# or in a pipeline:
@list |> map heat_index |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-heron">
<h3><a class="doc-anchor" href="#doc-heron">#</a> <code>heron</code></h3>
<p><code>heron</code> — geometry / physics builtin. Alias for <code>heron_area</code>.</p>
<pre><code class="lang-perl">my $result = heron $x
# or in a pipeline:
@list |> map heron |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-heron-area">
<h3><a class="doc-anchor" href="#doc-heron-area">#</a> <code>heron_area</code></h3>
<p><code>heron_area</code> — geometry / physics builtin.</p>
<pre><code class="lang-perl">my $result = heron_area $x
# or in a pipeline:
@list |> map heron_area |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hex-lower">
<h3><a class="doc-anchor" href="#doc-hex-lower">#</a> <code>hex_lower</code></h3>
<p><code>hex_lower</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = hex_lower $x
# or in a pipeline:
@list |> map hex_lower |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hex-of">
<h3><a class="doc-anchor" href="#doc-hex-of">#</a> <code>hex_of</code></h3>
<p><code>hex_of</code> — base conversion builtin. Alias for <code>to_hex</code>.</p>
<pre><code class="lang-perl">my $result = hex_of $x
# or in a pipeline:
@list |> map hex_of |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hex-to-bytes">
<h3><a class="doc-anchor" href="#doc-hex-to-bytes">#</a> <code>hex_to_bytes</code></h3>
<p><code>hex_to_bytes</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = hex_to_bytes $input
</code></pre>
</article>
<article class="doc-entry" id="doc-hex-to-rgb">
<h3><a class="doc-anchor" href="#doc-hex-to-rgb">#</a> <code>hex_to_rgb</code></h3>
<p><code>hex_to_rgb</code> — color / ansi builtin.</p>
<pre><code class="lang-perl">my $result = hex_to_rgb $input
</code></pre>
</article>
<article class="doc-entry" id="doc-hex-upper">
<h3><a class="doc-anchor" href="#doc-hex-upper">#</a> <code>hex_upper</code></h3>
<p><code>hex_upper</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = hex_upper $x
# or in a pipeline:
@list |> map hex_upper |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hidden">
<h3><a class="doc-anchor" href="#doc-hidden">#</a> <code>hidden</code></h3>
<p><code>hidden</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = hidden $x
# or in a pipeline:
@list |> map hidden |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-highpass-filter">
<h3><a class="doc-anchor" href="#doc-highpass-filter">#</a> <code>highpass_filter</code></h3>
<p><code>highpass_filter(\@signal, $cutoff)</code> (alias <code>hpf</code>) — applies a simple high-pass filter to remove low-frequency components (DC offset, drift). Signal = original - lowpass.</p>
<pre><code class="lang-perl">my @with_dc = map { 5 + sin($_/10) } 1..100
my $ac_only = hpf(\@with_dc, 0.1)
</code></pre>
</article>
<article class="doc-entry" id="doc-hist">
<h3><a class="doc-anchor" href="#doc-hist">#</a> <code>hist</code></h3>
<p><code>hist</code> — matrix operations (uncategorized batch) builtin. Alias for <code>histogram</code>.</p>
<pre><code class="lang-perl">my $result = hist $x
# or in a pipeline:
@list |> map hist |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-histogram">
<h3><a class="doc-anchor" href="#doc-histogram">#</a> <code>histogram</code></h3>
<p><code>histogram</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = histogram $x
# or in a pipeline:
@list |> map histogram |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-histogram-bins">
<h3><a class="doc-anchor" href="#doc-histogram-bins">#</a> <code>histogram_bins</code></h3>
<p><code>histogram_bins</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = histogram_bins $x
# or in a pipeline:
@list |> map histogram_bins |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hk">
<h3><a class="doc-anchor" href="#doc-hk">#</a> <code>hk</code></h3>
<p><code>hk</code> — hash helpers builtin. Alias for <code>has_key</code>.</p>
<pre><code class="lang-perl">my $result = hk $x
# or in a pipeline:
@list |> map hk |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-home-dir">
<h3><a class="doc-anchor" href="#doc-home-dir">#</a> <code>home_dir</code></h3>
<p><code>home_dir</code> — system introspection builtin.</p>
<pre><code class="lang-perl">my $result = home_dir $x
# or in a pipeline:
@list |> map home_dir |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hooke">
<h3><a class="doc-anchor" href="#doc-hooke">#</a> <code>hooke</code></h3>
<p><code>hooke</code> — physics formulas builtin. Alias for <code>spring_force</code>.</p>
<pre><code class="lang-perl">my $result = hooke $x
# or in a pipeline:
@list |> map hooke |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hostname-str">
<h3><a class="doc-anchor" href="#doc-hostname-str">#</a> <code>hostname_str</code></h3>
<p><code>hostname_str</code> — more process / system builtin.</p>
<pre><code class="lang-perl">my $result = hostname_str $x
# or in a pipeline:
@list |> map hostname_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hours-to-days">
<h3><a class="doc-anchor" href="#doc-hours-to-days">#</a> <code>hours_to_days</code></h3>
<p><code>hours_to_days</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = hours_to_days $input
</code></pre>
</article>
<article class="doc-entry" id="doc-hours-to-minutes">
<h3><a class="doc-anchor" href="#doc-hours-to-minutes">#</a> <code>hours_to_minutes</code></h3>
<p><code>hours_to_minutes</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = hours_to_minutes $input
</code></pre>
</article>
<article class="doc-entry" id="doc-hours-to-seconds">
<h3><a class="doc-anchor" href="#doc-hours-to-seconds">#</a> <code>hours_to_seconds</code></h3>
<p><code>hours_to_seconds</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = hours_to_seconds $input
</code></pre>
</article>
<article class="doc-entry" id="doc-hp-to-watts">
<h3><a class="doc-anchor" href="#doc-hp-to-watts">#</a> <code>hp_to_watts</code></h3>
<p><code>hp_to_watts</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = hp_to_watts $input
</code></pre>
</article>
<article class="doc-entry" id="doc-hr">
<h3><a class="doc-anchor" href="#doc-hr">#</a> <code>hr</code></h3>
<p><code>hr</code> — data / network builtin. Alias for <code>http_request</code>.</p>
<pre><code class="lang-perl">my $result = hr $x
# or in a pipeline:
@list |> map hr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hsl2rgb">
<h3><a class="doc-anchor" href="#doc-hsl2rgb">#</a> <code>hsl2rgb</code></h3>
<p><code>hsl2rgb</code> — color operations builtin. Alias for <code>hsl_to_rgb</code>.</p>
<pre><code class="lang-perl">my $result = hsl2rgb $x
# or in a pipeline:
@list |> map hsl2rgb |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hsl-to-rgb">
<h3><a class="doc-anchor" href="#doc-hsl-to-rgb">#</a> <code>hsl_to_rgb</code></h3>
<p><code>hsl_to_rgb</code> — color operations builtin.</p>
<pre><code class="lang-perl">my $result = hsl_to_rgb $input
</code></pre>
</article>
<article class="doc-entry" id="doc-hsv2rgb">
<h3><a class="doc-anchor" href="#doc-hsv2rgb">#</a> <code>hsv2rgb</code></h3>
<p><code>hsv2rgb</code> — color operations builtin. Alias for <code>hsv_to_rgb</code>.</p>
<pre><code class="lang-perl">my $result = hsv2rgb $x
# or in a pipeline:
@list |> map hsv2rgb |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hsv-to-rgb">
<h3><a class="doc-anchor" href="#doc-hsv-to-rgb">#</a> <code>hsv_to_rgb</code></h3>
<p><code>hsv_to_rgb</code> — color operations builtin.</p>
<pre><code class="lang-perl">my $result = hsv_to_rgb $input
</code></pre>
</article>
<article class="doc-entry" id="doc-html-decode">
<h3><a class="doc-anchor" href="#doc-html-decode">#</a> <code>html_decode</code></h3>
<p><code>html_decode</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = html_decode $x
# or in a pipeline:
@list |> map html_decode |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-html-encode">
<h3><a class="doc-anchor" href="#doc-html-encode">#</a> <code>html_encode</code></h3>
<p><code>html_encode</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = html_encode $x
# or in a pipeline:
@list |> map html_encode |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-htmld">
<h3><a class="doc-anchor" href="#doc-htmld">#</a> <code>htmld</code></h3>
<p><code>htmld</code> — extended stdlib builtin. Alias for <code>html_decode</code>.</p>
<pre><code class="lang-perl">my $result = htmld $x
# or in a pipeline:
@list |> map htmld |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-htmle">
<h3><a class="doc-anchor" href="#doc-htmle">#</a> <code>htmle</code></h3>
<p><code>htmle</code> — extended stdlib builtin. Alias for <code>html_encode</code>.</p>
<pre><code class="lang-perl">my $result = htmle $x
# or in a pipeline:
@list |> map htmle |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hubble-constant">
<h3><a class="doc-anchor" href="#doc-hubble-constant">#</a> <code>hubble_constant</code></h3>
<p><code>hubble_constant</code> — physics constants builtin.</p>
<pre><code class="lang-perl">my $result = hubble_constant $x
# or in a pipeline:
@list |> map hubble_constant |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-human-bytes">
<h3><a class="doc-anchor" href="#doc-human-bytes">#</a> <code>human_bytes</code></h3>
<p><code>human_bytes</code> — file stat / path builtin. Alias for <code>format_bytes</code>.</p>
<pre><code class="lang-perl">my $result = human_bytes $x
# or in a pipeline:
@list |> map human_bytes |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-human-duration">
<h3><a class="doc-anchor" href="#doc-human-duration">#</a> <code>human_duration</code></h3>
<p><code>human_duration</code> — file stat / path builtin. Alias for <code>format_duration</code>.</p>
<pre><code class="lang-perl">my $result = human_duration $x
# or in a pipeline:
@list |> map human_duration |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hxd">
<h3><a class="doc-anchor" href="#doc-hxd">#</a> <code>hxd</code></h3>
<p><code>hxd</code> — crypto / encoding builtin. Alias for <code>hex_decode</code>.</p>
<pre><code class="lang-perl">my $result = hxd $x
# or in a pipeline:
@list |> map hxd |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hxe">
<h3><a class="doc-anchor" href="#doc-hxe">#</a> <code>hxe</code></h3>
<p><code>hxe</code> — crypto / encoding builtin. Alias for <code>hex_encode</code>.</p>
<pre><code class="lang-perl">my $result = hxe $x
# or in a pipeline:
@list |> map hxe |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hyp">
<h3><a class="doc-anchor" href="#doc-hyp">#</a> <code>hyp</code></h3>
<p><code>hyp</code> — geometry / physics builtin. Alias for <code>triangle_hypotenuse</code>.</p>
<pre><code class="lang-perl">my $result = hyp $x
# or in a pipeline:
@list |> map hyp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-hypot">
<h3><a class="doc-anchor" href="#doc-hypot">#</a> <code>hypot</code></h3>
<p><code>hypot</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = hypot $x
# or in a pipeline:
@list |> map hypot |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-i64-max">
<h3><a class="doc-anchor" href="#doc-i64-max">#</a> <code>i64_max</code></h3>
<p><code>i64_max</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = i64_max $x
# or in a pipeline:
@list |> map i64_max |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-i64-min">
<h3><a class="doc-anchor" href="#doc-i64-min">#</a> <code>i64_min</code></h3>
<p><code>i64_min</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = i64_min $x
# or in a pipeline:
@list |> map i64_min |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ical">
<h3><a class="doc-anchor" href="#doc-ical">#</a> <code>ical</code></h3>
<p><code>ical</code> — haskell list functions builtin. Alias for <code>intercalate</code>.</p>
<pre><code class="lang-perl">my $result = ical $x
# or in a pipeline:
@list |> map ical |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-id">
<h3><a class="doc-anchor" href="#doc-id">#</a> <code>id</code></h3>
<p><code>id</code> — trivial numeric / predicate builtins builtin. Alias for <code>identity</code>.</p>
<pre><code class="lang-perl">my $result = id $x
# or in a pipeline:
@list |> map id |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-idct">
<h3><a class="doc-anchor" href="#doc-idct">#</a> <code>idct</code></h3>
<p><code>idct</code> computes the inverse DCT (Type-III). Reconstructs a signal from DCT coefficients.</p>
<pre><code class="lang-perl">my @signal = @{idct(dct([1,2,3,4]))}
</code></pre>
</article>
<article class="doc-entry" id="doc-ideal-gas">
<h3><a class="doc-anchor" href="#doc-ideal-gas">#</a> <code>ideal_gas</code></h3>
<p><code>ideal_gas</code> (alias <code>pv_nrt</code>) solves PV=nRT for the unknown (pass 0 for the value to solve). Args: P, V, n, T.</p>
<pre><code class="lang-perl">p pv_nrt(0, 0.0224, 1, 273.15) # pressure at STP
p pv_nrt(101325, 0, 1, 273.15) # volume at STP
</code></pre>
</article>
<article class="doc-entry" id="doc-ideal-gas-volume">
<h3><a class="doc-anchor" href="#doc-ideal-gas-volume">#</a> <code>ideal_gas_volume</code></h3>
<p><code>ideal_gas_volume</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = ideal_gas_volume $x
# or in a pipeline:
@list |> map ideal_gas_volume |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-identity">
<h3><a class="doc-anchor" href="#doc-identity">#</a> <code>identity</code></h3>
<p><code>identity</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = identity $x
# or in a pipeline:
@list |> map identity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-identity-matrix">
<h3><a class="doc-anchor" href="#doc-identity-matrix">#</a> <code>identity_matrix</code></h3>
<p><code>identity_matrix</code> — matrix / linear algebra builtin.</p>
<pre><code class="lang-perl">my $result = identity_matrix $x
# or in a pipeline:
@list |> map identity_matrix |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-idft">
<h3><a class="doc-anchor" href="#doc-idft">#</a> <code>idft</code></h3>
<p><code>idft(\@spectrum)</code> — computes the Inverse Discrete Fourier Transform. Takes arrayref of [re, im] pairs and returns the time-domain signal.</p>
<pre><code class="lang-perl">my $spectrum = dft(\@signal)
my $reconstructed = idft($spectrum)
</code></pre>
</article>
<article class="doc-entry" id="doc-idt">
<h3><a class="doc-anchor" href="#doc-idt">#</a> <code>idt</code></h3>
<p><code>idt</code> — extended stdlib builtin. Alias for <code>indent</code>.</p>
<pre><code class="lang-perl">my $result = idt $x
# or in a pipeline:
@list |> map idt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-idxb">
<h3><a class="doc-anchor" href="#doc-idxb">#</a> <code>idxb</code></h3>
<p><code>idxb</code> — go/general functional utilities builtin. Alias for <code>index_by</code>.</p>
<pre><code class="lang-perl">my $result = idxb $x
# or in a pipeline:
@list |> map idxb |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-if-else">
<h3><a class="doc-anchor" href="#doc-if-else">#</a> <code>if_else</code></h3>
<p><code>if_else</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = if_else $x
# or in a pipeline:
@list |> map if_else |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ilerp">
<h3><a class="doc-anchor" href="#doc-ilerp">#</a> <code>ilerp</code></h3>
<p><code>ilerp</code> — extended stdlib builtin. Alias for <code>inv_lerp</code>.</p>
<pre><code class="lang-perl">my $result = ilerp $x
# or in a pipeline:
@list |> map ilerp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-impedance-rlc">
<h3><a class="doc-anchor" href="#doc-impedance-rlc">#</a> <code>impedance_rlc</code></h3>
<p><code>impedance_rlc</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = impedance_rlc $x
# or in a pipeline:
@list |> map impedance_rlc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-impulse">
<h3><a class="doc-anchor" href="#doc-impulse">#</a> <code>impulse</code></h3>
<p><code>impulse($force, $time)</code> — compute impulse J = F×t (N⋅s). Change in momentum.</p>
<pre><code class="lang-perl">p impulse(100, 0.5) # 50 N⋅s
</code></pre>
</article>
<article class="doc-entry" id="doc-in-range">
<h3><a class="doc-anchor" href="#doc-in-range">#</a> <code>in_range</code></h3>
<p><code>in_range</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = in_range $x
# or in a pipeline:
@list |> map in_range |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-inc">
<h3><a class="doc-anchor" href="#doc-inc">#</a> <code>inc</code></h3>
<p><code>inc</code> — pipeline / string helpers builtin.</p>
<pre><code class="lang-perl">my $result = inc $x
# or in a pipeline:
@list |> map inc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-inc-each">
<h3><a class="doc-anchor" href="#doc-inc-each">#</a> <code>inc_each</code></h3>
<p><code>inc_each</code> — trivial numeric helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = inc_each $x
# or in a pipeline:
@list |> map inc_each |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-inches-to-cm">
<h3><a class="doc-anchor" href="#doc-inches-to-cm">#</a> <code>inches_to_cm</code></h3>
<p><code>inches_to_cm</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = inches_to_cm $input
</code></pre>
</article>
<article class="doc-entry" id="doc-includes-val">
<h3><a class="doc-anchor" href="#doc-includes-val">#</a> <code>includes_val</code></h3>
<p><code>includes_val</code> — javascript array/object methods builtin.</p>
<pre><code class="lang-perl">my $result = includes_val $x
# or in a pipeline:
@list |> map includes_val |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-incv">
<h3><a class="doc-anchor" href="#doc-incv">#</a> <code>incv</code></h3>
<p><code>incv</code> — javascript array/object methods builtin. Alias for <code>includes_val</code>.</p>
<pre><code class="lang-perl">my $result = incv $x
# or in a pipeline:
@list |> map incv |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-indenergy">
<h3><a class="doc-anchor" href="#doc-indenergy">#</a> <code>indenergy</code></h3>
<p><code>indenergy</code> — physics formulas builtin. Alias for <code>inductor_energy</code>.</p>
<pre><code class="lang-perl">my $result = indenergy $x
# or in a pipeline:
@list |> map indenergy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-indent">
<h3><a class="doc-anchor" href="#doc-indent">#</a> <code>indent</code></h3>
<p><code>indent</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = indent $x
# or in a pipeline:
@list |> map indent |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-indent-text">
<h3><a class="doc-anchor" href="#doc-indent-text">#</a> <code>indent_text</code></h3>
<p><code>indent_text</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = indent_text $x
# or in a pipeline:
@list |> map indent_text |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-index-by">
<h3><a class="doc-anchor" href="#doc-index-by">#</a> <code>index_by</code></h3>
<p><code>index_by</code> — go/general functional utilities builtin.</p>
<pre><code class="lang-perl">my $result = index_by $x
# or in a pipeline:
@list |> map index_by |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-index-of">
<h3><a class="doc-anchor" href="#doc-index-of">#</a> <code>index_of</code></h3>
<p><code>index_of</code> — collection (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = index_of $x
# or in a pipeline:
@list |> map index_of |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-index-of-elem">
<h3><a class="doc-anchor" href="#doc-index-of-elem">#</a> <code>index_of_elem</code></h3>
<p><code>index_of_elem</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = index_of_elem $x
# or in a pipeline:
@list |> map index_of_elem |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-indexes-of">
<h3><a class="doc-anchor" href="#doc-indexes-of">#</a> <code>indexes_of</code></h3>
<p><code>indexes_of</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = indexes_of $x
# or in a pipeline:
@list |> map indexes_of |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-inductor-energy">
<h3><a class="doc-anchor" href="#doc-inductor-energy">#</a> <code>inductor_energy</code></h3>
<p><code>inductor_energy</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = inductor_energy $x
# or in a pipeline:
@list |> map inductor_energy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-init-list">
<h3><a class="doc-anchor" href="#doc-init-list">#</a> <code>init_list</code></h3>
<p><code>init_list</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = init_list $x
# or in a pipeline:
@list |> map init_list |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-initials">
<h3><a class="doc-anchor" href="#doc-initials">#</a> <code>initials</code></h3>
<p><code>initials</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = initials $x
# or in a pipeline:
@list |> map initials |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-inits">
<h3><a class="doc-anchor" href="#doc-inits">#</a> <code>inits</code></h3>
<p><code>inits</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = inits $x
# or in a pipeline:
@list |> map inits |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-inits-str">
<h3><a class="doc-anchor" href="#doc-inits-str">#</a> <code>inits_str</code></h3>
<p><code>inits_str</code> — string processing (uncategorized batch) builtin. Alias for <code>initials</code>.</p>
<pre><code class="lang-perl">my $result = inits_str $x
# or in a pipeline:
@list |> map inits_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-inject">
<h3><a class="doc-anchor" href="#doc-inject">#</a> <code>inject</code></h3>
<p><code>inject</code> — functional / iterator builtin.</p>
<pre><code class="lang-perl">my $result = inject $x
# or in a pipeline:
@list |> map inject |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-inrng">
<h3><a class="doc-anchor" href="#doc-inrng">#</a> <code>inrng</code></h3>
<p><code>inrng</code> — extended stdlib builtin. Alias for <code>in_range</code>.</p>
<pre><code class="lang-perl">my $result = inrng $x
# or in a pipeline:
@list |> map inrng |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-insa">
<h3><a class="doc-anchor" href="#doc-insa">#</a> <code>insa</code></h3>
<p><code>insa</code> — go/general functional utilities builtin. Alias for <code>insert_at</code>.</p>
<pre><code class="lang-perl">my $result = insa $x
# or in a pipeline:
@list |> map insa |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-insert-at">
<h3><a class="doc-anchor" href="#doc-insert-at">#</a> <code>insert_at</code></h3>
<p><code>insert_at</code> — go/general functional utilities builtin.</p>
<pre><code class="lang-perl">my $result = insert_at $x
# or in a pipeline:
@list |> map insert_at |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-insert-sorted">
<h3><a class="doc-anchor" href="#doc-insert-sorted">#</a> <code>insert_sorted</code></h3>
<p><code>insert_sorted</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = insert_sorted $x
# or in a pipeline:
@list |> map insert_sorted |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-insert-str">
<h3><a class="doc-anchor" href="#doc-insert-str">#</a> <code>insert_str</code></h3>
<p><code>insert_str</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = insert_str $x
# or in a pipeline:
@list |> map insert_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-insp">
<h3><a class="doc-anchor" href="#doc-insp">#</a> <code>insp</code></h3>
<p><code>insp</code> — rust iterator methods builtin. Alias for <code>inspect</code>.</p>
<pre><code class="lang-perl">my $result = insp $x
# or in a pipeline:
@list |> map insp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-inspect">
<h3><a class="doc-anchor" href="#doc-inspect">#</a> <code>inspect</code></h3>
<p><code>inspect</code> — rust iterator methods builtin.</p>
<pre><code class="lang-perl">my $result = inspect $x
# or in a pipeline:
@list |> map inspect |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-inssrt">
<h3><a class="doc-anchor" href="#doc-inssrt">#</a> <code>inssrt</code></h3>
<p><code>inssrt</code> — additional missing stdlib functions builtin. Alias for <code>insert_sorted</code>.</p>
<pre><code class="lang-perl">my $result = inssrt $x
# or in a pipeline:
@list |> map inssrt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-int-bits">
<h3><a class="doc-anchor" href="#doc-int-bits">#</a> <code>int_bits</code></h3>
<p><code>int_bits</code> — math functions builtin.</p>
<pre><code class="lang-perl">my $result = int_bits $x
# or in a pipeline:
@list |> map int_bits |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-int-to-ipv4">
<h3><a class="doc-anchor" href="#doc-int-to-ipv4">#</a> <code>int_to_ipv4</code></h3>
<p><code>int_to_ipv4</code> — network / validation builtin.</p>
<pre><code class="lang-perl">my $result = int_to_ipv4 $input
</code></pre>
</article>
<article class="doc-entry" id="doc-int-to-roman">
<h3><a class="doc-anchor" href="#doc-int-to-roman">#</a> <code>int_to_roman</code></h3>
<p><code>int_to_roman</code> — roman numerals builtin.</p>
<pre><code class="lang-perl">my $result = int_to_roman $input
</code></pre>
</article>
<article class="doc-entry" id="doc-intercalate">
<h3><a class="doc-anchor" href="#doc-intercalate">#</a> <code>intercalate</code></h3>
<p><code>intercalate</code> — haskell list functions builtin.</p>
<pre><code class="lang-perl">my $result = intercalate $x
# or in a pipeline:
@list |> map intercalate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-interleave-lists">
<h3><a class="doc-anchor" href="#doc-interleave-lists">#</a> <code>interleave_lists</code></h3>
<p><code>interleave_lists</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = interleave_lists $x
# or in a pipeline:
@list |> map interleave_lists |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-interpose">
<h3><a class="doc-anchor" href="#doc-interpose">#</a> <code>interpose</code></h3>
<p><code>interpose</code> — go/general functional utilities builtin.</p>
<pre><code class="lang-perl">my $result = interpose $x
# or in a pipeline:
@list |> map interpose |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-intersect-list">
<h3><a class="doc-anchor" href="#doc-intersect-list">#</a> <code>intersect_list</code></h3>
<p><code>intersect_list</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = intersect_list $x
# or in a pipeline:
@list |> map intersect_list |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-intersperse">
<h3><a class="doc-anchor" href="#doc-intersperse">#</a> <code>intersperse</code></h3>
<p><code>intersperse</code> — collection helpers (trivial) builtin. Alias for <code>riffle</code>.</p>
<pre><code class="lang-perl">my $result = intersperse $x
# or in a pipeline:
@list |> map intersperse |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-intersperse-char">
<h3><a class="doc-anchor" href="#doc-intersperse-char">#</a> <code>intersperse_char</code></h3>
<p><code>intersperse_char</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = intersperse_char $x
# or in a pipeline:
@list |> map intersperse_char |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-intersperse-val">
<h3><a class="doc-anchor" href="#doc-intersperse-val">#</a> <code>intersperse_val</code></h3>
<p><code>intersperse_val</code> — haskell list functions builtin.</p>
<pre><code class="lang-perl">my $result = intersperse_val $x
# or in a pipeline:
@list |> map intersperse_val |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-intersperse-with">
<h3><a class="doc-anchor" href="#doc-intersperse-with">#</a> <code>intersperse_with</code></h3>
<p><code>intersperse_with</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = intersperse_with $x
# or in a pipeline:
@list |> map intersperse_with |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-intl">
<h3><a class="doc-anchor" href="#doc-intl">#</a> <code>intl</code></h3>
<p><code>intl</code> — additional missing stdlib functions builtin. Alias for <code>intersect_list</code>.</p>
<pre><code class="lang-perl">my $result = intl $x
# or in a pipeline:
@list |> map intl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-into">
<h3><a class="doc-anchor" href="#doc-into">#</a> <code>into</code></h3>
<p><code>into</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = into $x
# or in a pipeline:
@list |> map into |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-inv-lerp">
<h3><a class="doc-anchor" href="#doc-inv-lerp">#</a> <code>inv_lerp</code></h3>
<p><code>inv_lerp</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = inv_lerp $x
# or in a pipeline:
@list |> map inv_lerp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-inverse">
<h3><a class="doc-anchor" href="#doc-inverse">#</a> <code>inverse</code></h3>
<p><code>inverse</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = inverse $x
# or in a pipeline:
@list |> map inverse |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-inverse-lerp">
<h3><a class="doc-anchor" href="#doc-inverse-lerp">#</a> <code>inverse_lerp</code></h3>
<p><code>inverse_lerp</code> — math formulas builtin.</p>
<pre><code class="lang-perl">my $result = inverse_lerp $x
# or in a pipeline:
@list |> map inverse_lerp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-invert">
<h3><a class="doc-anchor" href="#doc-invert">#</a> <code>invert</code></h3>
<p><code>invert</code> — hash helpers builtin.</p>
<pre><code class="lang-perl">my $result = invert $x
# or in a pipeline:
@list |> map invert |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ioctl">
<h3><a class="doc-anchor" href="#doc-ioctl">#</a> <code>ioctl</code></h3>
<p><code>ioctl</code> — ipc builtin.</p>
<pre><code class="lang-perl">my $result = ioctl $x
# or in a pipeline:
@list |> map ioctl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ipos">
<h3><a class="doc-anchor" href="#doc-ipos">#</a> <code>ipos</code></h3>
<p><code>ipos</code> — go/general functional utilities builtin. Alias for <code>interpose</code>.</p>
<pre><code class="lang-perl">my $result = ipos $x
# or in a pipeline:
@list |> map ipos |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ipv4-to-int">
<h3><a class="doc-anchor" href="#doc-ipv4-to-int">#</a> <code>ipv4_to_int</code></h3>
<p><code>ipv4_to_int</code> — network / validation builtin.</p>
<pre><code class="lang-perl">my $result = ipv4_to_int $input
</code></pre>
</article>
<article class="doc-entry" id="doc-iqr">
<h3><a class="doc-anchor" href="#doc-iqr">#</a> <code>iqr</code></h3>
<p><code>iqr</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = iqr $x
# or in a pipeline:
@list |> map iqr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-irr">
<h3><a class="doc-anchor" href="#doc-irr">#</a> <code>irr</code></h3>
<p><code>irr(@cashflows)</code> — computes the Internal Rate of Return for a series of cash flows. First value is typically negative (initial investment). Uses Newton-Raphson iteration.</p>
<pre><code class="lang-perl">my @cf = (-1000, 300, 420, 680)
p irr(@cf) # ~0.166 (16.6%)
</code></pre>
</article>
<article class="doc-entry" id="doc-is-abundant">
<h3><a class="doc-anchor" href="#doc-is-abundant">#</a> <code>is_abundant</code></h3>
<p><code>is_abundant</code> — number theory / primes builtin.</p>
<pre><code class="lang-perl">my $result = is_abundant $x
# or in a pipeline:
@list |> map is_abundant |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-alnum">
<h3><a class="doc-anchor" href="#doc-is-alnum">#</a> <code>is_alnum</code></h3>
<p><code>is_alnum</code> — trivial string ops builtin.</p>
<pre><code class="lang-perl">my $result = is_alnum $x
# or in a pipeline:
@list |> map is_alnum |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-alpha">
<h3><a class="doc-anchor" href="#doc-is-alpha">#</a> <code>is_alpha</code></h3>
<p><code>is_alpha</code> — trivial string ops builtin.</p>
<pre><code class="lang-perl">my $result = is_alpha $x
# or in a pipeline:
@list |> map is_alpha |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-anagram">
<h3><a class="doc-anchor" href="#doc-is-anagram">#</a> <code>is_anagram</code></h3>
<p><code>is_anagram</code> — dsp / signal (extended) builtin.</p>
<pre><code class="lang-perl">my $result = is_anagram $x
# or in a pipeline:
@list |> map is_anagram |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-array">
<h3><a class="doc-anchor" href="#doc-is-array">#</a> <code>is_array</code></h3>
<p><code>is_array</code> — trivial type predicates builtin.</p>
<pre><code class="lang-perl">my $result = is_array $x
# or in a pipeline:
@list |> map is_array |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-arrayref">
<h3><a class="doc-anchor" href="#doc-is-arrayref">#</a> <code>is_arrayref</code></h3>
<p><code>is_arrayref</code> — trivial type predicates builtin. Alias for <code>is_array</code>.</p>
<pre><code class="lang-perl">my $result = is_arrayref $x
# or in a pipeline:
@list |> map is_arrayref |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-asc">
<h3><a class="doc-anchor" href="#doc-is-asc">#</a> <code>is_asc</code></h3>
<p><code>is_asc</code> — predicates (batch 2) builtin. Alias for <code>is_sorted</code>.</p>
<pre><code class="lang-perl">my $result = is_asc $x
# or in a pipeline:
@list |> map is_asc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-ascii">
<h3><a class="doc-anchor" href="#doc-is-ascii">#</a> <code>is_ascii</code></h3>
<p><code>is_ascii</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_ascii $x
# or in a pipeline:
@list |> map is_ascii |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-balanced-parens">
<h3><a class="doc-anchor" href="#doc-is-balanced-parens">#</a> <code>is_balanced_parens</code></h3>
<p><code>is_balanced_parens</code> — dsp / signal (extended) builtin.</p>
<pre><code class="lang-perl">my $result = is_balanced_parens $x
# or in a pipeline:
@list |> map is_balanced_parens |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-base64">
<h3><a class="doc-anchor" href="#doc-is-base64">#</a> <code>is_base64</code></h3>
<p><code>is_base64</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_base64 $x
# or in a pipeline:
@list |> map is_base64 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-between">
<h3><a class="doc-anchor" href="#doc-is-between">#</a> <code>is_between</code></h3>
<p><code>is_between</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_between $x
# or in a pipeline:
@list |> map is_between |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-binary-str">
<h3><a class="doc-anchor" href="#doc-is-binary-str">#</a> <code>is_binary_str</code></h3>
<p><code>is_binary_str</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_binary_str $x
# or in a pipeline:
@list |> map is_binary_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-bipartite-graph">
<h3><a class="doc-anchor" href="#doc-is-bipartite-graph">#</a> <code>is_bipartite_graph</code></h3>
<p><code>is_bipartite_graph</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_bipartite_graph $x
# or in a pipeline:
@list |> map is_bipartite_graph |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-blank">
<h3><a class="doc-anchor" href="#doc-is-blank">#</a> <code>is_blank</code></h3>
<p><code>is_blank</code> — trivial string ops builtin.</p>
<pre><code class="lang-perl">my $result = is_blank $x
# or in a pipeline:
@list |> map is_blank |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-blank-or-nil">
<h3><a class="doc-anchor" href="#doc-is-blank-or-nil">#</a> <code>is_blank_or_nil</code></h3>
<p><code>is_blank_or_nil</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_blank_or_nil $x
# or in a pipeline:
@list |> map is_blank_or_nil |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-callable">
<h3><a class="doc-anchor" href="#doc-is-callable">#</a> <code>is_callable</code></h3>
<p><code>is_callable</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = is_callable $x
# or in a pipeline:
@list |> map is_callable |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-code">
<h3><a class="doc-anchor" href="#doc-is-code">#</a> <code>is_code</code></h3>
<p><code>is_code</code> — trivial type predicates builtin.</p>
<pre><code class="lang-perl">my $result = is_code $x
# or in a pipeline:
@list |> map is_code |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-coderef">
<h3><a class="doc-anchor" href="#doc-is-coderef">#</a> <code>is_coderef</code></h3>
<p><code>is_coderef</code> — trivial type predicates builtin. Alias for <code>is_code</code>.</p>
<pre><code class="lang-perl">my $result = is_coderef $x
# or in a pipeline:
@list |> map is_coderef |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-consonant">
<h3><a class="doc-anchor" href="#doc-is-consonant">#</a> <code>is_consonant</code></h3>
<p><code>is_consonant</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = is_consonant $x
# or in a pipeline:
@list |> map is_consonant |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-control">
<h3><a class="doc-anchor" href="#doc-is-control">#</a> <code>is_control</code></h3>
<p><code>is_control</code> — dsp / signal (extended) builtin.</p>
<pre><code class="lang-perl">my $result = is_control $x
# or in a pipeline:
@list |> map is_control |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-coprime">
<h3><a class="doc-anchor" href="#doc-is-coprime">#</a> <code>is_coprime</code></h3>
<p><code>is_coprime</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = is_coprime $x
# or in a pipeline:
@list |> map is_coprime |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-credit-card">
<h3><a class="doc-anchor" href="#doc-is-credit-card">#</a> <code>is_credit_card</code></h3>
<p><code>is_credit_card</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_credit_card $x
# or in a pipeline:
@list |> map is_credit_card |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-def">
<h3><a class="doc-anchor" href="#doc-is-def">#</a> <code>is_def</code></h3>
<p><code>is_def</code> — trivial type predicates builtin. Alias for <code>is_defined</code>.</p>
<pre><code class="lang-perl">my $result = is_def $x
# or in a pipeline:
@list |> map is_def |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-deficient">
<h3><a class="doc-anchor" href="#doc-is-deficient">#</a> <code>is_deficient</code></h3>
<p><code>is_deficient</code> — number theory / primes builtin.</p>
<pre><code class="lang-perl">my $result = is_deficient $x
# or in a pipeline:
@list |> map is_deficient |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-defined">
<h3><a class="doc-anchor" href="#doc-is-defined">#</a> <code>is_defined</code></h3>
<p><code>is_defined</code> — trivial type predicates builtin.</p>
<pre><code class="lang-perl">my $result = is_defined $x
# or in a pipeline:
@list |> map is_defined |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-desc">
<h3><a class="doc-anchor" href="#doc-is-desc">#</a> <code>is_desc</code></h3>
<p><code>is_desc</code> — predicates (batch 2) builtin. Alias for <code>is_sorted_desc</code>.</p>
<pre><code class="lang-perl">my $result = is_desc $x
# or in a pipeline:
@list |> map is_desc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-digit">
<h3><a class="doc-anchor" href="#doc-is-digit">#</a> <code>is_digit</code></h3>
<p><code>is_digit</code> — trivial string ops builtin.</p>
<pre><code class="lang-perl">my $result = is_digit $x
# or in a pipeline:
@list |> map is_digit |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-divisible-by">
<h3><a class="doc-anchor" href="#doc-is-divisible-by">#</a> <code>is_divisible_by</code></h3>
<p><code>is_divisible_by</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_divisible_by $x
# or in a pipeline:
@list |> map is_divisible_by |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-email">
<h3><a class="doc-anchor" href="#doc-is-email">#</a> <code>is_email</code></h3>
<p><code>is_email</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_email $x
# or in a pipeline:
@list |> map is_email |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-empty">
<h3><a class="doc-anchor" href="#doc-is-empty">#</a> <code>is_empty</code></h3>
<p><code>is_empty</code> — trivial string ops builtin.</p>
<pre><code class="lang-perl">my $result = is_empty $x
# or in a pipeline:
@list |> map is_empty |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-empty-arr">
<h3><a class="doc-anchor" href="#doc-is-empty-arr">#</a> <code>is_empty_arr</code></h3>
<p><code>is_empty_arr</code> — predicates (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = is_empty_arr $x
# or in a pipeline:
@list |> map is_empty_arr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-empty-hash">
<h3><a class="doc-anchor" href="#doc-is-empty-hash">#</a> <code>is_empty_hash</code></h3>
<p><code>is_empty_hash</code> — predicates (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = is_empty_hash $x
# or in a pipeline:
@list |> map is_empty_hash |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-even">
<h3><a class="doc-anchor" href="#doc-is-even">#</a> <code>is_even</code></h3>
<p><code>is_even</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_even $x
# or in a pipeline:
@list |> map is_even |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-even-num">
<h3><a class="doc-anchor" href="#doc-is-even-num">#</a> <code>is_even_num</code></h3>
<p><code>is_even_num</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_even_num $x
# or in a pipeline:
@list |> map is_even_num |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-executable">
<h3><a class="doc-anchor" href="#doc-is-executable">#</a> <code>is_executable</code></h3>
<p><code>is_executable</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = is_executable $x
# or in a pipeline:
@list |> map is_executable |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-falsy">
<h3><a class="doc-anchor" href="#doc-is-falsy">#</a> <code>is_falsy</code></h3>
<p><code>is_falsy</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_falsy $x
# or in a pipeline:
@list |> map is_falsy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-fibonacci">
<h3><a class="doc-anchor" href="#doc-is-fibonacci">#</a> <code>is_fibonacci</code></h3>
<p><code>is_fibonacci</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_fibonacci $x
# or in a pipeline:
@list |> map is_fibonacci |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-finite">
<h3><a class="doc-anchor" href="#doc-is-finite">#</a> <code>is_finite</code></h3>
<p><code>is_finite</code> — trig / math (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = is_finite $x
# or in a pipeline:
@list |> map is_finite |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-float">
<h3><a class="doc-anchor" href="#doc-is-float">#</a> <code>is_float</code></h3>
<p><code>is_float</code> — trivial type predicates builtin.</p>
<pre><code class="lang-perl">my $result = is_float $x
# or in a pipeline:
@list |> map is_float |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-harshad">
<h3><a class="doc-anchor" href="#doc-is-harshad">#</a> <code>is_harshad</code></h3>
<p><code>is_harshad</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = is_harshad $x
# or in a pipeline:
@list |> map is_harshad |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-hash">
<h3><a class="doc-anchor" href="#doc-is-hash">#</a> <code>is_hash</code></h3>
<p><code>is_hash</code> — trivial type predicates builtin.</p>
<pre><code class="lang-perl">my $result = is_hash $x
# or in a pipeline:
@list |> map is_hash |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-hashref">
<h3><a class="doc-anchor" href="#doc-is-hashref">#</a> <code>is_hashref</code></h3>
<p><code>is_hashref</code> — trivial type predicates builtin. Alias for <code>is_hash</code>.</p>
<pre><code class="lang-perl">my $result = is_hashref $x
# or in a pipeline:
@list |> map is_hashref |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-heterogram">
<h3><a class="doc-anchor" href="#doc-is-heterogram">#</a> <code>is_heterogram</code></h3>
<p><code>is_heterogram</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = is_heterogram $x
# or in a pipeline:
@list |> map is_heterogram |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-hex-color">
<h3><a class="doc-anchor" href="#doc-is-hex-color">#</a> <code>is_hex_color</code></h3>
<p><code>is_hex_color</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_hex_color $x
# or in a pipeline:
@list |> map is_hex_color |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-hex-str">
<h3><a class="doc-anchor" href="#doc-is-hex-str">#</a> <code>is_hex_str</code></h3>
<p><code>is_hex_str</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_hex_str $x
# or in a pipeline:
@list |> map is_hex_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-hostname-valid">
<h3><a class="doc-anchor" href="#doc-is-hostname-valid">#</a> <code>is_hostname_valid</code></h3>
<p><code>is_hostname_valid</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_hostname_valid $x
# or in a pipeline:
@list |> map is_hostname_valid |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-iban">
<h3><a class="doc-anchor" href="#doc-is-iban">#</a> <code>is_iban</code></h3>
<p><code>is_iban</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_iban $x
# or in a pipeline:
@list |> map is_iban |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-in-range">
<h3><a class="doc-anchor" href="#doc-is-in-range">#</a> <code>is_in_range</code></h3>
<p><code>is_in_range</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_in_range $x
# or in a pipeline:
@list |> map is_in_range |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-inf">
<h3><a class="doc-anchor" href="#doc-is-inf">#</a> <code>is_inf</code></h3>
<p><code>is_inf</code> — trig / math (batch 2) builtin. Alias for <code>is_infinite</code>.</p>
<pre><code class="lang-perl">my $result = is_inf $x
# or in a pipeline:
@list |> map is_inf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-infinite">
<h3><a class="doc-anchor" href="#doc-is-infinite">#</a> <code>is_infinite</code></h3>
<p><code>is_infinite</code> — trig / math (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = is_infinite $x
# or in a pipeline:
@list |> map is_infinite |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-int">
<h3><a class="doc-anchor" href="#doc-is-int">#</a> <code>is_int</code></h3>
<p><code>is_int</code> — trivial type predicates builtin.</p>
<pre><code class="lang-perl">my $result = is_int $x
# or in a pipeline:
@list |> map is_int |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-integer">
<h3><a class="doc-anchor" href="#doc-is-integer">#</a> <code>is_integer</code></h3>
<p><code>is_integer</code> — trivial type predicates builtin. Alias for <code>is_int</code>.</p>
<pre><code class="lang-perl">my $result = is_integer $x
# or in a pipeline:
@list |> map is_integer |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-ipv4">
<h3><a class="doc-anchor" href="#doc-is-ipv4">#</a> <code>is_ipv4</code></h3>
<p><code>is_ipv4</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_ipv4 $x
# or in a pipeline:
@list |> map is_ipv4 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-ipv4-addr">
<h3><a class="doc-anchor" href="#doc-is-ipv4-addr">#</a> <code>is_ipv4_addr</code></h3>
<p><code>is_ipv4_addr</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_ipv4_addr $x
# or in a pipeline:
@list |> map is_ipv4_addr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-ipv6-addr">
<h3><a class="doc-anchor" href="#doc-is-ipv6-addr">#</a> <code>is_ipv6_addr</code></h3>
<p><code>is_ipv6_addr</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_ipv6_addr $x
# or in a pipeline:
@list |> map is_ipv6_addr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-isbn10">
<h3><a class="doc-anchor" href="#doc-is-isbn10">#</a> <code>is_isbn10</code></h3>
<p><code>is_isbn10</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_isbn10 $x
# or in a pipeline:
@list |> map is_isbn10 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-isbn13">
<h3><a class="doc-anchor" href="#doc-is-isbn13">#</a> <code>is_isbn13</code></h3>
<p><code>is_isbn13</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_isbn13 $x
# or in a pipeline:
@list |> map is_isbn13 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-iso-date">
<h3><a class="doc-anchor" href="#doc-is-iso-date">#</a> <code>is_iso_date</code></h3>
<p><code>is_iso_date</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_iso_date $x
# or in a pipeline:
@list |> map is_iso_date |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-iso-datetime">
<h3><a class="doc-anchor" href="#doc-is-iso-datetime">#</a> <code>is_iso_datetime</code></h3>
<p><code>is_iso_datetime</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_iso_datetime $x
# or in a pipeline:
@list |> map is_iso_datetime |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-iso-time">
<h3><a class="doc-anchor" href="#doc-is-iso-time">#</a> <code>is_iso_time</code></h3>
<p><code>is_iso_time</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_iso_time $x
# or in a pipeline:
@list |> map is_iso_time |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-isogram">
<h3><a class="doc-anchor" href="#doc-is-isogram">#</a> <code>is_isogram</code></h3>
<p><code>is_isogram</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = is_isogram $x
# or in a pipeline:
@list |> map is_isogram |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-json">
<h3><a class="doc-anchor" href="#doc-is-json">#</a> <code>is_json</code></h3>
<p><code>is_json</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_json $x
# or in a pipeline:
@list |> map is_json |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-kaprekar">
<h3><a class="doc-anchor" href="#doc-is-kaprekar">#</a> <code>is_kaprekar</code></h3>
<p><code>is_kaprekar</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = is_kaprekar $x
# or in a pipeline:
@list |> map is_kaprekar |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-leap">
<h3><a class="doc-anchor" href="#doc-is-leap">#</a> <code>is_leap</code></h3>
<p><code>is_leap</code> — date helpers builtin. Alias for <code>is_leap_year</code>.</p>
<pre><code class="lang-perl">my $result = is_leap $x
# or in a pipeline:
@list |> map is_leap |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-leap-year">
<h3><a class="doc-anchor" href="#doc-is-leap-year">#</a> <code>is_leap_year</code></h3>
<p><code>is_leap_year</code> — date helpers builtin.</p>
<pre><code class="lang-perl">my $result = is_leap_year $x
# or in a pipeline:
@list |> map is_leap_year |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-lower">
<h3><a class="doc-anchor" href="#doc-is-lower">#</a> <code>is_lower</code></h3>
<p><code>is_lower</code> — trivial string ops builtin.</p>
<pre><code class="lang-perl">my $result = is_lower $x
# or in a pipeline:
@list |> map is_lower |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-mac-addr">
<h3><a class="doc-anchor" href="#doc-is-mac-addr">#</a> <code>is_mac_addr</code></h3>
<p><code>is_mac_addr</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_mac_addr $x
# or in a pipeline:
@list |> map is_mac_addr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-match">
<h3><a class="doc-anchor" href="#doc-is-match">#</a> <code>is_match</code></h3>
<p><code>is_match</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_match $x
# or in a pipeline:
@list |> map is_match |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-monotonic">
<h3><a class="doc-anchor" href="#doc-is-monotonic">#</a> <code>is_monotonic</code></h3>
<p><code>is_monotonic</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = is_monotonic $x
# or in a pipeline:
@list |> map is_monotonic |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-multiple-of">
<h3><a class="doc-anchor" href="#doc-is-multiple-of">#</a> <code>is_multiple_of</code></h3>
<p><code>is_multiple_of</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_multiple_of $x
# or in a pipeline:
@list |> map is_multiple_of |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-nan">
<h3><a class="doc-anchor" href="#doc-is-nan">#</a> <code>is_nan</code></h3>
<p><code>is_nan</code> — trig / math (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = is_nan $x
# or in a pipeline:
@list |> map is_nan |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-narcissistic">
<h3><a class="doc-anchor" href="#doc-is-narcissistic">#</a> <code>is_narcissistic</code></h3>
<p><code>is_narcissistic</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = is_narcissistic $x
# or in a pipeline:
@list |> map is_narcissistic |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-negative">
<h3><a class="doc-anchor" href="#doc-is-negative">#</a> <code>is_negative</code></h3>
<p><code>is_negative</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_negative $x
# or in a pipeline:
@list |> map is_negative |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-negative-num">
<h3><a class="doc-anchor" href="#doc-is-negative-num">#</a> <code>is_negative_num</code></h3>
<p><code>is_negative_num</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_negative_num $x
# or in a pipeline:
@list |> map is_negative_num |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-nil">
<h3><a class="doc-anchor" href="#doc-is-nil">#</a> <code>is_nil</code></h3>
<p><code>is_nil</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_nil $x
# or in a pipeline:
@list |> map is_nil |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-nonzero">
<h3><a class="doc-anchor" href="#doc-is-nonzero">#</a> <code>is_nonzero</code></h3>
<p><code>is_nonzero</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_nonzero $x
# or in a pipeline:
@list |> map is_nonzero |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-numeric">
<h3><a class="doc-anchor" href="#doc-is-numeric">#</a> <code>is_numeric</code></h3>
<p><code>is_numeric</code> — trivial string ops builtin.</p>
<pre><code class="lang-perl">my $result = is_numeric $x
# or in a pipeline:
@list |> map is_numeric |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-numeric-string">
<h3><a class="doc-anchor" href="#doc-is-numeric-string">#</a> <code>is_numeric_string</code></h3>
<p><code>is_numeric_string</code> — dsp / signal (extended) builtin.</p>
<pre><code class="lang-perl">my $result = is_numeric_string $x
# or in a pipeline:
@list |> map is_numeric_string |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-octal-str">
<h3><a class="doc-anchor" href="#doc-is-octal-str">#</a> <code>is_octal_str</code></h3>
<p><code>is_octal_str</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_octal_str $x
# or in a pipeline:
@list |> map is_octal_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-odd">
<h3><a class="doc-anchor" href="#doc-is-odd">#</a> <code>is_odd</code></h3>
<p><code>is_odd</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_odd $x
# or in a pipeline:
@list |> map is_odd |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-odd-num">
<h3><a class="doc-anchor" href="#doc-is-odd-num">#</a> <code>is_odd_num</code></h3>
<p><code>is_odd_num</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_odd_num $x
# or in a pipeline:
@list |> map is_odd_num |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-pair">
<h3><a class="doc-anchor" href="#doc-is-pair">#</a> <code>is_pair</code></h3>
<p><code>is_pair</code> — predicates (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = is_pair $x
# or in a pipeline:
@list |> map is_pair |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-palindrome">
<h3><a class="doc-anchor" href="#doc-is-palindrome">#</a> <code>is_palindrome</code></h3>
<p><code>is_palindrome</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = is_palindrome $x
# or in a pipeline:
@list |> map is_palindrome |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-pangram">
<h3><a class="doc-anchor" href="#doc-is-pangram">#</a> <code>is_pangram</code></h3>
<p><code>is_pangram</code> — dsp / signal (extended) builtin.</p>
<pre><code class="lang-perl">my $result = is_pangram $x
# or in a pipeline:
@list |> map is_pangram |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-pentagonal">
<h3><a class="doc-anchor" href="#doc-is-pentagonal">#</a> <code>is_pentagonal</code></h3>
<p><code>is_pentagonal</code> — number theory / primes builtin.</p>
<pre><code class="lang-perl">my $result = is_pentagonal $x
# or in a pipeline:
@list |> map is_pentagonal |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-perfect">
<h3><a class="doc-anchor" href="#doc-is-perfect">#</a> <code>is_perfect</code></h3>
<p><code>is_perfect</code> — number theory / primes builtin.</p>
<pre><code class="lang-perl">my $result = is_perfect $x
# or in a pipeline:
@list |> map is_perfect |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-perfect-square">
<h3><a class="doc-anchor" href="#doc-is-perfect-square">#</a> <code>is_perfect_square</code></h3>
<p><code>is_perfect_square</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_perfect_square $x
# or in a pipeline:
@list |> map is_perfect_square |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-permutation">
<h3><a class="doc-anchor" href="#doc-is-permutation">#</a> <code>is_permutation</code></h3>
<p><code>is_permutation</code> — predicates (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = is_permutation $x
# or in a pipeline:
@list |> map is_permutation |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-phone-num">
<h3><a class="doc-anchor" href="#doc-is-phone-num">#</a> <code>is_phone_num</code></h3>
<p><code>is_phone_num</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_phone_num $x
# or in a pipeline:
@list |> map is_phone_num |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-port-num">
<h3><a class="doc-anchor" href="#doc-is-port-num">#</a> <code>is_port_num</code></h3>
<p><code>is_port_num</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_port_num $x
# or in a pipeline:
@list |> map is_port_num |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-positive">
<h3><a class="doc-anchor" href="#doc-is-positive">#</a> <code>is_positive</code></h3>
<p><code>is_positive</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_positive $x
# or in a pipeline:
@list |> map is_positive |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-positive-num">
<h3><a class="doc-anchor" href="#doc-is-positive-num">#</a> <code>is_positive_num</code></h3>
<p><code>is_positive_num</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_positive_num $x
# or in a pipeline:
@list |> map is_positive_num |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-pow2">
<h3><a class="doc-anchor" href="#doc-is-pow2">#</a> <code>is_pow2</code></h3>
<p><code>is_pow2</code> — trivial numeric / predicate builtins builtin. Alias for <code>is_power_of_two</code>.</p>
<pre><code class="lang-perl">my $result = is_pow2 $x
# or in a pipeline:
@list |> map is_pow2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-power-of">
<h3><a class="doc-anchor" href="#doc-is-power-of">#</a> <code>is_power_of</code></h3>
<p><code>is_power_of</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_power_of $x
# or in a pipeline:
@list |> map is_power_of |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-power-of-two">
<h3><a class="doc-anchor" href="#doc-is-power-of-two">#</a> <code>is_power_of_two</code></h3>
<p><code>is_power_of_two</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = is_power_of_two $x
# or in a pipeline:
@list |> map is_power_of_two |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-prefix">
<h3><a class="doc-anchor" href="#doc-is-prefix">#</a> <code>is_prefix</code></h3>
<p><code>is_prefix</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_prefix $x
# or in a pipeline:
@list |> map is_prefix |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-present">
<h3><a class="doc-anchor" href="#doc-is-present">#</a> <code>is_present</code></h3>
<p><code>is_present</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_present $x
# or in a pipeline:
@list |> map is_present |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-prime">
<h3><a class="doc-anchor" href="#doc-is-prime">#</a> <code>is_prime</code></h3>
<p><code>is_prime</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = is_prime $x
# or in a pipeline:
@list |> map is_prime |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-printable">
<h3><a class="doc-anchor" href="#doc-is-printable">#</a> <code>is_printable</code></h3>
<p><code>is_printable</code> — dsp / signal (extended) builtin.</p>
<pre><code class="lang-perl">my $result = is_printable $x
# or in a pipeline:
@list |> map is_printable |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-probable-prime">
<h3><a class="doc-anchor" href="#doc-is-probable-prime">#</a> <code>is_probable_prime</code></h3>
<p><code>miller_rabin</code> (aliases <code>millerrabin</code>, <code>is_probable_prime</code>) performs a probabilistic primality test with k rounds (default 20).</p>
<pre><code class="lang-perl">p millerrabin(104729) # 1 (prime)
p millerrabin(104730) # 0 (composite)
</code></pre>
</article>
<article class="doc-entry" id="doc-is-readable">
<h3><a class="doc-anchor" href="#doc-is-readable">#</a> <code>is_readable</code></h3>
<p><code>is_readable</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = is_readable $x
# or in a pipeline:
@list |> map is_readable |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-ref">
<h3><a class="doc-anchor" href="#doc-is-ref">#</a> <code>is_ref</code></h3>
<p><code>is_ref</code> — trivial type predicates builtin.</p>
<pre><code class="lang-perl">my $result = is_ref $x
# or in a pipeline:
@list |> map is_ref |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-regex-valid">
<h3><a class="doc-anchor" href="#doc-is-regex-valid">#</a> <code>is_regex_valid</code></h3>
<p><code>is_regex_valid</code> — more regex builtin.</p>
<pre><code class="lang-perl">my $result = is_regex_valid $x
# or in a pipeline:
@list |> map is_regex_valid |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-root">
<h3><a class="doc-anchor" href="#doc-is-root">#</a> <code>is_root</code></h3>
<p><code>is_root</code> — more process / system builtin.</p>
<pre><code class="lang-perl">my $result = is_root $x
# or in a pipeline:
@list |> map is_root |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-semver">
<h3><a class="doc-anchor" href="#doc-is-semver">#</a> <code>is_semver</code></h3>
<p><code>is_semver</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_semver $x
# or in a pipeline:
@list |> map is_semver |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-slug">
<h3><a class="doc-anchor" href="#doc-is-slug">#</a> <code>is_slug</code></h3>
<p><code>is_slug</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_slug $x
# or in a pipeline:
@list |> map is_slug |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-smith">
<h3><a class="doc-anchor" href="#doc-is-smith">#</a> <code>is_smith</code></h3>
<p><code>is_smith</code> — number theory / primes builtin.</p>
<pre><code class="lang-perl">my $result = is_smith $x
# or in a pipeline:
@list |> map is_smith |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-sorted">
<h3><a class="doc-anchor" href="#doc-is-sorted">#</a> <code>is_sorted</code></h3>
<p><code>is_sorted</code> — predicates (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = is_sorted $x
# or in a pipeline:
@list |> map is_sorted |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-sorted-by">
<h3><a class="doc-anchor" href="#doc-is-sorted-by">#</a> <code>is_sorted_by</code></h3>
<p><code>is_sorted_by</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = is_sorted_by $x
# or in a pipeline:
@list |> map is_sorted_by |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-sorted-desc">
<h3><a class="doc-anchor" href="#doc-is-sorted-desc">#</a> <code>is_sorted_desc</code></h3>
<p><code>is_sorted_desc</code> — predicates (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = is_sorted_desc $x
# or in a pipeline:
@list |> map is_sorted_desc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-space">
<h3><a class="doc-anchor" href="#doc-is-space">#</a> <code>is_space</code></h3>
<p><code>is_space</code> — trivial string ops builtin.</p>
<pre><code class="lang-perl">my $result = is_space $x
# or in a pipeline:
@list |> map is_space |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-square">
<h3><a class="doc-anchor" href="#doc-is-square">#</a> <code>is_square</code></h3>
<p><code>is_square</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = is_square $x
# or in a pipeline:
@list |> map is_square |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-squarefree">
<h3><a class="doc-anchor" href="#doc-is-squarefree">#</a> <code>is_squarefree</code></h3>
<p><code>is_squarefree</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = is_squarefree $x
# or in a pipeline:
@list |> map is_squarefree |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-str">
<h3><a class="doc-anchor" href="#doc-is-str">#</a> <code>is_str</code></h3>
<p><code>is_str</code> — trivial type predicates builtin. Alias for <code>is_string</code>.</p>
<pre><code class="lang-perl">my $result = is_str $x
# or in a pipeline:
@list |> map is_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-strictly-decreasing">
<h3><a class="doc-anchor" href="#doc-is-strictly-decreasing">#</a> <code>is_strictly_decreasing</code></h3>
<p><code>is_strictly_decreasing</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_strictly_decreasing $x
# or in a pipeline:
@list |> map is_strictly_decreasing |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-strictly-increasing">
<h3><a class="doc-anchor" href="#doc-is-strictly-increasing">#</a> <code>is_strictly_increasing</code></h3>
<p><code>is_strictly_increasing</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_strictly_increasing $x
# or in a pipeline:
@list |> map is_strictly_increasing |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-string">
<h3><a class="doc-anchor" href="#doc-is-string">#</a> <code>is_string</code></h3>
<p><code>is_string</code> — trivial type predicates builtin.</p>
<pre><code class="lang-perl">my $result = is_string $x
# or in a pipeline:
@list |> map is_string |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-subset">
<h3><a class="doc-anchor" href="#doc-is-subset">#</a> <code>is_subset</code></h3>
<p><code>is_subset</code> — predicates (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = is_subset $x
# or in a pipeline:
@list |> map is_subset |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-suffix">
<h3><a class="doc-anchor" href="#doc-is-suffix">#</a> <code>is_suffix</code></h3>
<p><code>is_suffix</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_suffix $x
# or in a pipeline:
@list |> map is_suffix |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-superset">
<h3><a class="doc-anchor" href="#doc-is-superset">#</a> <code>is_superset</code></h3>
<p><code>is_superset</code> — predicates (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = is_superset $x
# or in a pipeline:
@list |> map is_superset |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-symlink">
<h3><a class="doc-anchor" href="#doc-is-symlink">#</a> <code>is_symlink</code></h3>
<p><code>is_symlink</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = is_symlink $x
# or in a pipeline:
@list |> map is_symlink |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-triangular">
<h3><a class="doc-anchor" href="#doc-is-triangular">#</a> <code>is_triangular</code></h3>
<p><code>is_triangular</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_triangular $x
# or in a pipeline:
@list |> map is_triangular |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-triple">
<h3><a class="doc-anchor" href="#doc-is-triple">#</a> <code>is_triple</code></h3>
<p><code>is_triple</code> — predicates (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = is_triple $x
# or in a pipeline:
@list |> map is_triple |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-truthy">
<h3><a class="doc-anchor" href="#doc-is-truthy">#</a> <code>is_truthy</code></h3>
<p><code>is_truthy</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_truthy $x
# or in a pipeline:
@list |> map is_truthy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-tty">
<h3><a class="doc-anchor" href="#doc-is-tty">#</a> <code>is_tty</code></h3>
<p><code>is_tty</code> — more process / system builtin.</p>
<pre><code class="lang-perl">my $result = is_tty $x
# or in a pipeline:
@list |> map is_tty |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-undef">
<h3><a class="doc-anchor" href="#doc-is-undef">#</a> <code>is_undef</code></h3>
<p><code>is_undef</code> — trivial type predicates builtin.</p>
<pre><code class="lang-perl">my $result = is_undef $x
# or in a pipeline:
@list |> map is_undef |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-upper">
<h3><a class="doc-anchor" href="#doc-is-upper">#</a> <code>is_upper</code></h3>
<p><code>is_upper</code> — trivial string ops builtin.</p>
<pre><code class="lang-perl">my $result = is_upper $x
# or in a pipeline:
@list |> map is_upper |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-url">
<h3><a class="doc-anchor" href="#doc-is-url">#</a> <code>is_url</code></h3>
<p><code>is_url</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_url $x
# or in a pipeline:
@list |> map is_url |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-us-zip">
<h3><a class="doc-anchor" href="#doc-is-us-zip">#</a> <code>is_us_zip</code></h3>
<p><code>is_us_zip</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_us_zip $x
# or in a pipeline:
@list |> map is_us_zip |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-uuid">
<h3><a class="doc-anchor" href="#doc-is-uuid">#</a> <code>is_uuid</code></h3>
<p><code>is_uuid</code> — id helpers builtin.</p>
<pre><code class="lang-perl">my $result = is_uuid $x
# or in a pipeline:
@list |> map is_uuid |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-valid-cidr">
<h3><a class="doc-anchor" href="#doc-is-valid-cidr">#</a> <code>is_valid_cidr</code></h3>
<p><code>is_valid_cidr</code> — dsp / signal (extended) builtin.</p>
<pre><code class="lang-perl">my $result = is_valid_cidr $x
# or in a pipeline:
@list |> map is_valid_cidr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-valid-cron">
<h3><a class="doc-anchor" href="#doc-is-valid-cron">#</a> <code>is_valid_cron</code></h3>
<p><code>is_valid_cron</code> — dsp / signal (extended) builtin.</p>
<pre><code class="lang-perl">my $result = is_valid_cron $x
# or in a pipeline:
@list |> map is_valid_cron |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-valid-date">
<h3><a class="doc-anchor" href="#doc-is-valid-date">#</a> <code>is_valid_date</code></h3>
<p><code>is_valid_date</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = is_valid_date $x
# or in a pipeline:
@list |> map is_valid_date |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-valid-email">
<h3><a class="doc-anchor" href="#doc-is-valid-email">#</a> <code>is_valid_email</code></h3>
<p><code>is_valid_email</code> — network / validation builtin.</p>
<pre><code class="lang-perl">my $result = is_valid_email $x
# or in a pipeline:
@list |> map is_valid_email |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-valid-hex">
<h3><a class="doc-anchor" href="#doc-is-valid-hex">#</a> <code>is_valid_hex</code></h3>
<p><code>is_valid_hex</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = is_valid_hex $x
# or in a pipeline:
@list |> map is_valid_hex |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-valid-hex-color">
<h3><a class="doc-anchor" href="#doc-is-valid-hex-color">#</a> <code>is_valid_hex_color</code></h3>
<p><code>is_valid_hex_color</code> — dsp / signal (extended) builtin.</p>
<pre><code class="lang-perl">my $result = is_valid_hex_color $x
# or in a pipeline:
@list |> map is_valid_hex_color |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-valid-ipv4">
<h3><a class="doc-anchor" href="#doc-is-valid-ipv4">#</a> <code>is_valid_ipv4</code></h3>
<p><code>is_valid_ipv4</code> — network / validation builtin.</p>
<pre><code class="lang-perl">my $result = is_valid_ipv4 $x
# or in a pipeline:
@list |> map is_valid_ipv4 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-valid-ipv6">
<h3><a class="doc-anchor" href="#doc-is-valid-ipv6">#</a> <code>is_valid_ipv6</code></h3>
<p><code>is_valid_ipv6</code> — network / validation builtin.</p>
<pre><code class="lang-perl">my $result = is_valid_ipv6 $x
# or in a pipeline:
@list |> map is_valid_ipv6 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-valid-latitude">
<h3><a class="doc-anchor" href="#doc-is-valid-latitude">#</a> <code>is_valid_latitude</code></h3>
<p><code>is_valid_latitude</code> — dsp / signal (extended) builtin.</p>
<pre><code class="lang-perl">my $result = is_valid_latitude $x
# or in a pipeline:
@list |> map is_valid_latitude |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-valid-longitude">
<h3><a class="doc-anchor" href="#doc-is-valid-longitude">#</a> <code>is_valid_longitude</code></h3>
<p><code>is_valid_longitude</code> — dsp / signal (extended) builtin.</p>
<pre><code class="lang-perl">my $result = is_valid_longitude $x
# or in a pipeline:
@list |> map is_valid_longitude |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-valid-mime">
<h3><a class="doc-anchor" href="#doc-is-valid-mime">#</a> <code>is_valid_mime</code></h3>
<p><code>is_valid_mime</code> — dsp / signal (extended) builtin.</p>
<pre><code class="lang-perl">my $result = is_valid_mime $x
# or in a pipeline:
@list |> map is_valid_mime |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-valid-url">
<h3><a class="doc-anchor" href="#doc-is-valid-url">#</a> <code>is_valid_url</code></h3>
<p><code>is_valid_url</code> — network / validation builtin.</p>
<pre><code class="lang-perl">my $result = is_valid_url $x
# or in a pipeline:
@list |> map is_valid_url |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-vowel">
<h3><a class="doc-anchor" href="#doc-is-vowel">#</a> <code>is_vowel</code></h3>
<p><code>is_vowel</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = is_vowel $x
# or in a pipeline:
@list |> map is_vowel |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-weekday">
<h3><a class="doc-anchor" href="#doc-is-weekday">#</a> <code>is_weekday</code></h3>
<p><code>is_weekday</code> — date (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = is_weekday $x
# or in a pipeline:
@list |> map is_weekday |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-weekend">
<h3><a class="doc-anchor" href="#doc-is-weekend">#</a> <code>is_weekend</code></h3>
<p><code>is_weekend</code> — date (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = is_weekend $x
# or in a pipeline:
@list |> map is_weekend |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-whitespace">
<h3><a class="doc-anchor" href="#doc-is-whitespace">#</a> <code>is_whitespace</code></h3>
<p><code>is_whitespace</code> — trivial string ops builtin. Alias for <code>is_space</code>.</p>
<pre><code class="lang-perl">my $result = is_whitespace $x
# or in a pipeline:
@list |> map is_whitespace |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-whole">
<h3><a class="doc-anchor" href="#doc-is-whole">#</a> <code>is_whole</code></h3>
<p><code>is_whole</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_whole $x
# or in a pipeline:
@list |> map is_whole |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-whole-num">
<h3><a class="doc-anchor" href="#doc-is-whole-num">#</a> <code>is_whole_num</code></h3>
<p><code>is_whole_num</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_whole_num $x
# or in a pipeline:
@list |> map is_whole_num |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-writable">
<h3><a class="doc-anchor" href="#doc-is-writable">#</a> <code>is_writable</code></h3>
<p><code>is_writable</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = is_writable $x
# or in a pipeline:
@list |> map is_writable |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-zero">
<h3><a class="doc-anchor" href="#doc-is-zero">#</a> <code>is_zero</code></h3>
<p><code>is_zero</code> — predicates (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = is_zero $x
# or in a pipeline:
@list |> map is_zero |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-is-zero-num">
<h3><a class="doc-anchor" href="#doc-is-zero-num">#</a> <code>is_zero_num</code></h3>
<p><code>is_zero_num</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = is_zero_num $x
# or in a pipeline:
@list |> map is_zero_num |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isabun">
<h3><a class="doc-anchor" href="#doc-isabun">#</a> <code>isabun</code></h3>
<p><code>isabun</code> — number theory / primes builtin. Alias for <code>is_abundant</code>.</p>
<pre><code class="lang-perl">my $result = isabun $x
# or in a pipeline:
@list |> map isabun |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isanag">
<h3><a class="doc-anchor" href="#doc-isanag">#</a> <code>isanag</code></h3>
<p><code>isanag</code> — dsp / signal (extended) builtin. Alias for <code>is_anagram</code>.</p>
<pre><code class="lang-perl">my $result = isanag $x
# or in a pipeline:
@list |> map isanag |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isasc">
<h3><a class="doc-anchor" href="#doc-isasc">#</a> <code>isasc</code></h3>
<p><code>isasc</code> — extended stdlib builtin. Alias for <code>is_ascii</code>.</p>
<pre><code class="lang-perl">my $result = isasc $x
# or in a pipeline:
@list |> map isasc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isb64">
<h3><a class="doc-anchor" href="#doc-isb64">#</a> <code>isb64</code></h3>
<p><code>isb64</code> — extended stdlib builtin. Alias for <code>is_base64</code>.</p>
<pre><code class="lang-perl">my $result = isb64 $x
# or in a pipeline:
@list |> map isb64 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isbalp">
<h3><a class="doc-anchor" href="#doc-isbalp">#</a> <code>isbalp</code></h3>
<p><code>isbalp</code> — dsp / signal (extended) builtin. Alias for <code>is_balanced_parens</code>.</p>
<pre><code class="lang-perl">my $result = isbalp $x
# or in a pipeline:
@list |> map isbalp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isbin">
<h3><a class="doc-anchor" href="#doc-isbin">#</a> <code>isbin</code></h3>
<p><code>isbin</code> — extended stdlib builtin. Alias for <code>is_binary_str</code>.</p>
<pre><code class="lang-perl">my $result = isbin $x
# or in a pipeline:
@list |> map isbin |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isbip">
<h3><a class="doc-anchor" href="#doc-isbip">#</a> <code>isbip</code></h3>
<p><code>isbip</code> — extended stdlib builtin. Alias for <code>is_bipartite_graph</code>.</p>
<pre><code class="lang-perl">my $result = isbip $x
# or in a pipeline:
@list |> map isbip |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isbn10">
<h3><a class="doc-anchor" href="#doc-isbn10">#</a> <code>isbn10</code></h3>
<p><code>isbn10</code> — extended stdlib builtin. Alias for <code>is_isbn10</code>.</p>
<pre><code class="lang-perl">my $result = isbn10 $x
# or in a pipeline:
@list |> map isbn10 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isbn13">
<h3><a class="doc-anchor" href="#doc-isbn13">#</a> <code>isbn13</code></h3>
<p><code>isbn13</code> — extended stdlib builtin. Alias for <code>is_isbn13</code>.</p>
<pre><code class="lang-perl">my $result = isbn13 $x
# or in a pipeline:
@list |> map isbn13 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-iscc">
<h3><a class="doc-anchor" href="#doc-iscc">#</a> <code>iscc</code></h3>
<p><code>iscc</code> — extended stdlib builtin. Alias for <code>is_credit_card</code>.</p>
<pre><code class="lang-perl">my $result = iscc $x
# or in a pipeline:
@list |> map iscc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-iscidr">
<h3><a class="doc-anchor" href="#doc-iscidr">#</a> <code>iscidr</code></h3>
<p><code>iscidr</code> — dsp / signal (extended) builtin. Alias for <code>is_valid_cidr</code>.</p>
<pre><code class="lang-perl">my $result = iscidr $x
# or in a pipeline:
@list |> map iscidr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-iscopr">
<h3><a class="doc-anchor" href="#doc-iscopr">#</a> <code>iscopr</code></h3>
<p><code>iscopr</code> — extended stdlib batch 3 builtin. Alias for <code>is_coprime</code>.</p>
<pre><code class="lang-perl">my $result = iscopr $x
# or in a pipeline:
@list |> map iscopr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-iscron">
<h3><a class="doc-anchor" href="#doc-iscron">#</a> <code>iscron</code></h3>
<p><code>iscron</code> — dsp / signal (extended) builtin. Alias for <code>is_valid_cron</code>.</p>
<pre><code class="lang-perl">my $result = iscron $x
# or in a pipeline:
@list |> map iscron |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isctrl">
<h3><a class="doc-anchor" href="#doc-isctrl">#</a> <code>isctrl</code></h3>
<p><code>isctrl</code> — dsp / signal (extended) builtin. Alias for <code>is_control</code>.</p>
<pre><code class="lang-perl">my $result = isctrl $x
# or in a pipeline:
@list |> map isctrl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isdefi">
<h3><a class="doc-anchor" href="#doc-isdefi">#</a> <code>isdefi</code></h3>
<p><code>isdefi</code> — number theory / primes builtin. Alias for <code>is_deficient</code>.</p>
<pre><code class="lang-perl">my $result = isdefi $x
# or in a pipeline:
@list |> map isdefi |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-iseven">
<h3><a class="doc-anchor" href="#doc-iseven">#</a> <code>iseven</code></h3>
<p><code>iseven</code> — extended stdlib builtin. Alias for <code>is_even_num</code>.</p>
<pre><code class="lang-perl">my $result = iseven $x
# or in a pipeline:
@list |> map iseven |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isharsh">
<h3><a class="doc-anchor" href="#doc-isharsh">#</a> <code>isharsh</code></h3>
<p><code>isharsh</code> — extended stdlib batch 3 builtin. Alias for <code>is_harshad</code>.</p>
<pre><code class="lang-perl">my $result = isharsh $x
# or in a pipeline:
@list |> map isharsh |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ishet">
<h3><a class="doc-anchor" href="#doc-ishet">#</a> <code>ishet</code></h3>
<p><code>ishet</code> — extended stdlib batch 3 builtin. Alias for <code>is_heterogram</code>.</p>
<pre><code class="lang-perl">my $result = ishet $x
# or in a pipeline:
@list |> map ishet |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ishex">
<h3><a class="doc-anchor" href="#doc-ishex">#</a> <code>ishex</code></h3>
<p><code>ishex</code> — extended stdlib builtin. Alias for <code>is_hex_str</code>.</p>
<pre><code class="lang-perl">my $result = ishex $x
# or in a pipeline:
@list |> map ishex |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ishexc">
<h3><a class="doc-anchor" href="#doc-ishexc">#</a> <code>ishexc</code></h3>
<p><code>ishexc</code> — dsp / signal (extended) builtin. Alias for <code>is_valid_hex_color</code>.</p>
<pre><code class="lang-perl">my $result = ishexc $x
# or in a pipeline:
@list |> map ishexc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ishost">
<h3><a class="doc-anchor" href="#doc-ishost">#</a> <code>ishost</code></h3>
<p><code>ishost</code> — extended stdlib builtin. Alias for <code>is_hostname_valid</code>.</p>
<pre><code class="lang-perl">my $result = ishost $x
# or in a pipeline:
@list |> map ishost |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isiban">
<h3><a class="doc-anchor" href="#doc-isiban">#</a> <code>isiban</code></h3>
<p><code>isiban</code> — extended stdlib builtin. Alias for <code>is_iban</code>.</p>
<pre><code class="lang-perl">my $result = isiban $x
# or in a pipeline:
@list |> map isiban |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isip4">
<h3><a class="doc-anchor" href="#doc-isip4">#</a> <code>isip4</code></h3>
<p><code>isip4</code> — extended stdlib builtin. Alias for <code>is_ipv4_addr</code>.</p>
<pre><code class="lang-perl">my $result = isip4 $x
# or in a pipeline:
@list |> map isip4 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isip6">
<h3><a class="doc-anchor" href="#doc-isip6">#</a> <code>isip6</code></h3>
<p><code>isip6</code> — extended stdlib builtin. Alias for <code>is_ipv6_addr</code>.</p>
<pre><code class="lang-perl">my $result = isip6 $x
# or in a pipeline:
@list |> map isip6 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isiso">
<h3><a class="doc-anchor" href="#doc-isiso">#</a> <code>isiso</code></h3>
<p><code>isiso</code> — extended stdlib batch 3 builtin. Alias for <code>is_isogram</code>.</p>
<pre><code class="lang-perl">my $result = isiso $x
# or in a pipeline:
@list |> map isiso |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isisodt">
<h3><a class="doc-anchor" href="#doc-isisodt">#</a> <code>isisodt</code></h3>
<p><code>isisodt</code> — extended stdlib builtin. Alias for <code>is_iso_date</code>.</p>
<pre><code class="lang-perl">my $result = isisodt $x
# or in a pipeline:
@list |> map isisodt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isisodtm">
<h3><a class="doc-anchor" href="#doc-isisodtm">#</a> <code>isisodtm</code></h3>
<p><code>isisodtm</code> — extended stdlib builtin. Alias for <code>is_iso_datetime</code>.</p>
<pre><code class="lang-perl">my $result = isisodtm $x
# or in a pipeline:
@list |> map isisodtm |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isisotm">
<h3><a class="doc-anchor" href="#doc-isisotm">#</a> <code>isisotm</code></h3>
<p><code>isisotm</code> — extended stdlib builtin. Alias for <code>is_iso_time</code>.</p>
<pre><code class="lang-perl">my $result = isisotm $x
# or in a pipeline:
@list |> map isisotm |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isjson">
<h3><a class="doc-anchor" href="#doc-isjson">#</a> <code>isjson</code></h3>
<p><code>isjson</code> — extended stdlib builtin. Alias for <code>is_json</code>.</p>
<pre><code class="lang-perl">my $result = isjson $x
# or in a pipeline:
@list |> map isjson |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-iskap">
<h3><a class="doc-anchor" href="#doc-iskap">#</a> <code>iskap</code></h3>
<p><code>iskap</code> — extended stdlib batch 3 builtin. Alias for <code>is_kaprekar</code>.</p>
<pre><code class="lang-perl">my $result = iskap $x
# or in a pipeline:
@list |> map iskap |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isl">
<h3><a class="doc-anchor" href="#doc-isl">#</a> <code>isl</code></h3>
<p><code>isl</code> — python/ruby stdlib builtin. Alias for <code>islice</code>.</p>
<pre><code class="lang-perl">my $result = isl $x
# or in a pipeline:
@list |> map isl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-islat">
<h3><a class="doc-anchor" href="#doc-islat">#</a> <code>islat</code></h3>
<p><code>islat</code> — dsp / signal (extended) builtin. Alias for <code>is_valid_latitude</code>.</p>
<pre><code class="lang-perl">my $result = islat $x
# or in a pipeline:
@list |> map islat |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-islice">
<h3><a class="doc-anchor" href="#doc-islice">#</a> <code>islice</code></h3>
<p><code>islice</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = islice $x
# or in a pipeline:
@list |> map islice |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-islon">
<h3><a class="doc-anchor" href="#doc-islon">#</a> <code>islon</code></h3>
<p><code>islon</code> — dsp / signal (extended) builtin. Alias for <code>is_valid_longitude</code>.</p>
<pre><code class="lang-perl">my $result = islon $x
# or in a pipeline:
@list |> map islon |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ism">
<h3><a class="doc-anchor" href="#doc-ism">#</a> <code>ism</code></h3>
<p><code>ism</code> — extended stdlib builtin. Alias for <code>is_match</code>.</p>
<pre><code class="lang-perl">my $result = ism $x
# or in a pipeline:
@list |> map ism |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ismac">
<h3><a class="doc-anchor" href="#doc-ismac">#</a> <code>ismac</code></h3>
<p><code>ismac</code> — extended stdlib builtin. Alias for <code>is_mac_addr</code>.</p>
<pre><code class="lang-perl">my $result = ismac $x
# or in a pipeline:
@list |> map ismac |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ismime">
<h3><a class="doc-anchor" href="#doc-ismime">#</a> <code>ismime</code></h3>
<p><code>ismime</code> — dsp / signal (extended) builtin. Alias for <code>is_valid_mime</code>.</p>
<pre><code class="lang-perl">my $result = ismime $x
# or in a pipeline:
@list |> map ismime |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ismono">
<h3><a class="doc-anchor" href="#doc-ismono">#</a> <code>ismono</code></h3>
<p><code>ismono</code> — extended stdlib batch 3 builtin. Alias for <code>is_monotonic</code>.</p>
<pre><code class="lang-perl">my $result = ismono $x
# or in a pipeline:
@list |> map ismono |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isnarc">
<h3><a class="doc-anchor" href="#doc-isnarc">#</a> <code>isnarc</code></h3>
<p><code>isnarc</code> — extended stdlib batch 3 builtin. Alias for <code>is_narcissistic</code>.</p>
<pre><code class="lang-perl">my $result = isnarc $x
# or in a pipeline:
@list |> map isnarc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isneg">
<h3><a class="doc-anchor" href="#doc-isneg">#</a> <code>isneg</code></h3>
<p><code>isneg</code> — extended stdlib builtin. Alias for <code>is_negative_num</code>.</p>
<pre><code class="lang-perl">my $result = isneg $x
# or in a pipeline:
@list |> map isneg |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isnumstr">
<h3><a class="doc-anchor" href="#doc-isnumstr">#</a> <code>isnumstr</code></h3>
<p><code>isnumstr</code> — dsp / signal (extended) builtin. Alias for <code>is_numeric_string</code>.</p>
<pre><code class="lang-perl">my $result = isnumstr $x
# or in a pipeline:
@list |> map isnumstr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isoct">
<h3><a class="doc-anchor" href="#doc-isoct">#</a> <code>isoct</code></h3>
<p><code>isoct</code> — extended stdlib builtin. Alias for <code>is_octal_str</code>.</p>
<pre><code class="lang-perl">my $result = isoct $x
# or in a pipeline:
@list |> map isoct |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isodd">
<h3><a class="doc-anchor" href="#doc-isodd">#</a> <code>isodd</code></h3>
<p><code>isodd</code> — extended stdlib builtin. Alias for <code>is_odd_num</code>.</p>
<pre><code class="lang-perl">my $result = isodd $x
# or in a pipeline:
@list |> map isodd |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isp">
<h3><a class="doc-anchor" href="#doc-isp">#</a> <code>isp</code></h3>
<p><code>isp</code> — haskell list functions builtin. Alias for <code>intersperse_val</code>.</p>
<pre><code class="lang-perl">my $result = isp $x
# or in a pipeline:
@list |> map isp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ispang">
<h3><a class="doc-anchor" href="#doc-ispang">#</a> <code>ispang</code></h3>
<p><code>ispang</code> — dsp / signal (extended) builtin. Alias for <code>is_pangram</code>.</p>
<pre><code class="lang-perl">my $result = ispang $x
# or in a pipeline:
@list |> map ispang |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ispent">
<h3><a class="doc-anchor" href="#doc-ispent">#</a> <code>ispent</code></h3>
<p><code>ispent</code> — number theory / primes builtin. Alias for <code>is_pentagonal</code>.</p>
<pre><code class="lang-perl">my $result = ispent $x
# or in a pipeline:
@list |> map ispent |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isperf">
<h3><a class="doc-anchor" href="#doc-isperf">#</a> <code>isperf</code></h3>
<p><code>isperf</code> — number theory / primes builtin. Alias for <code>is_perfect</code>.</p>
<pre><code class="lang-perl">my $result = isperf $x
# or in a pipeline:
@list |> map isperf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isphone">
<h3><a class="doc-anchor" href="#doc-isphone">#</a> <code>isphone</code></h3>
<p><code>isphone</code> — extended stdlib builtin. Alias for <code>is_phone_num</code>.</p>
<pre><code class="lang-perl">my $result = isphone $x
# or in a pipeline:
@list |> map isphone |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isport">
<h3><a class="doc-anchor" href="#doc-isport">#</a> <code>isport</code></h3>
<p><code>isport</code> — extended stdlib builtin. Alias for <code>is_port_num</code>.</p>
<pre><code class="lang-perl">my $result = isport $x
# or in a pipeline:
@list |> map isport |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ispos">
<h3><a class="doc-anchor" href="#doc-ispos">#</a> <code>ispos</code></h3>
<p><code>ispos</code> — extended stdlib builtin. Alias for <code>is_positive_num</code>.</p>
<pre><code class="lang-perl">my $result = ispos $x
# or in a pipeline:
@list |> map ispos |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isprint">
<h3><a class="doc-anchor" href="#doc-isprint">#</a> <code>isprint</code></h3>
<p><code>isprint</code> — dsp / signal (extended) builtin. Alias for <code>is_printable</code>.</p>
<pre><code class="lang-perl">my $result = isprint $x
# or in a pipeline:
@list |> map isprint |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ispw">
<h3><a class="doc-anchor" href="#doc-ispw">#</a> <code>ispw</code></h3>
<p><code>ispw</code> — additional missing stdlib functions builtin. Alias for <code>intersperse_with</code>.</p>
<pre><code class="lang-perl">my $result = ispw $x
# or in a pipeline:
@list |> map ispw |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isslug">
<h3><a class="doc-anchor" href="#doc-isslug">#</a> <code>isslug</code></h3>
<p><code>isslug</code> — extended stdlib builtin. Alias for <code>is_slug</code>.</p>
<pre><code class="lang-perl">my $result = isslug $x
# or in a pipeline:
@list |> map isslug |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-issmith">
<h3><a class="doc-anchor" href="#doc-issmith">#</a> <code>issmith</code></h3>
<p><code>issmith</code> — number theory / primes builtin. Alias for <code>is_smith</code>.</p>
<pre><code class="lang-perl">my $result = issmith $x
# or in a pipeline:
@list |> map issmith |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-issqfr">
<h3><a class="doc-anchor" href="#doc-issqfr">#</a> <code>issqfr</code></h3>
<p><code>issqfr</code> — extended stdlib batch 3 builtin. Alias for <code>is_squarefree</code>.</p>
<pre><code class="lang-perl">my $result = issqfr $x
# or in a pipeline:
@list |> map issqfr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-issrtb">
<h3><a class="doc-anchor" href="#doc-issrtb">#</a> <code>issrtb</code></h3>
<p><code>issrtb</code> — additional missing stdlib functions builtin. Alias for <code>is_sorted_by</code>.</p>
<pre><code class="lang-perl">my $result = issrtb $x
# or in a pipeline:
@list |> map issrtb |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-issv">
<h3><a class="doc-anchor" href="#doc-issv">#</a> <code>issv</code></h3>
<p><code>issv</code> — extended stdlib builtin. Alias for <code>is_semver</code>.</p>
<pre><code class="lang-perl">my $result = issv $x
# or in a pipeline:
@list |> map issv |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-isvdate">
<h3><a class="doc-anchor" href="#doc-isvdate">#</a> <code>isvdate</code></h3>
<p><code>isvdate</code> — extended stdlib batch 3 builtin. Alias for <code>is_valid_date</code>.</p>
<pre><code class="lang-perl">my $result = isvdate $x
# or in a pipeline:
@list |> map isvdate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-iswhole">
<h3><a class="doc-anchor" href="#doc-iswhole">#</a> <code>iswhole</code></h3>
<p><code>iswhole</code> — extended stdlib builtin. Alias for <code>is_whole_num</code>.</p>
<pre><code class="lang-perl">my $result = iswhole $x
# or in a pipeline:
@list |> map iswhole |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-iszero">
<h3><a class="doc-anchor" href="#doc-iszero">#</a> <code>iszero</code></h3>
<p><code>iszero</code> — extended stdlib builtin. Alias for <code>is_zero_num</code>.</p>
<pre><code class="lang-perl">my $result = iszero $x
# or in a pipeline:
@list |> map iszero |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-iszip">
<h3><a class="doc-anchor" href="#doc-iszip">#</a> <code>iszip</code></h3>
<p><code>iszip</code> — extended stdlib builtin. Alias for <code>is_us_zip</code>.</p>
<pre><code class="lang-perl">my $result = iszip $x
# or in a pipeline:
@list |> map iszip |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-italic">
<h3><a class="doc-anchor" href="#doc-italic">#</a> <code>italic</code></h3>
<p><code>italic</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = italic $x
# or in a pipeline:
@list |> map italic |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-iter">
<h3><a class="doc-anchor" href="#doc-iter">#</a> <code>iter</code></h3>
<p><code>iter</code> — algebraic match builtin. Alias for <code>iterate</code>.</p>
<pre><code class="lang-perl">my $result = iter $x
# or in a pipeline:
@list |> map iter |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-iterate">
<h3><a class="doc-anchor" href="#doc-iterate">#</a> <code>iterate</code></h3>
<p><code>iterate</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = iterate $x
# or in a pipeline:
@list |> map iterate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-iterate-n">
<h3><a class="doc-anchor" href="#doc-iterate-n">#</a> <code>iterate_n</code></h3>
<p><code>iterate_n</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = iterate_n $x
# or in a pipeline:
@list |> map iterate_n |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-jaccard">
<h3><a class="doc-anchor" href="#doc-jaccard">#</a> <code>jaccard</code></h3>
<p><code>jaccard</code> — extended stdlib batch 3 builtin. Alias for <code>jaccard_index</code>.</p>
<pre><code class="lang-perl">my $result = jaccard $x
# or in a pipeline:
@list |> map jaccard |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-jaccard-index">
<h3><a class="doc-anchor" href="#doc-jaccard-index">#</a> <code>jaccard_index</code></h3>
<p><code>jaccard_index</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = jaccard_index $x
# or in a pipeline:
@list |> map jaccard_index |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-jaccard-similarity">
<h3><a class="doc-anchor" href="#doc-jaccard-similarity">#</a> <code>jaccard_similarity</code></h3>
<p><code>jaccard_similarity</code> — math functions builtin.</p>
<pre><code class="lang-perl">my $result = jaccard_similarity $x
# or in a pipeline:
@list |> map jaccard_similarity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-jaro-similarity">
<h3><a class="doc-anchor" href="#doc-jaro-similarity">#</a> <code>jaro_similarity</code></h3>
<p><code>jaro_similarity</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = jaro_similarity $x
# or in a pipeline:
@list |> map jaro_similarity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-jarosim">
<h3><a class="doc-anchor" href="#doc-jarosim">#</a> <code>jarosim</code></h3>
<p><code>jarosim</code> — extended stdlib batch 3 builtin. Alias for <code>jaro_similarity</code>.</p>
<pre><code class="lang-perl">my $result = jarosim $x
# or in a pipeline:
@list |> map jarosim |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-jd">
<h3><a class="doc-anchor" href="#doc-jd">#</a> <code>jd</code></h3>
<p><code>jd</code> — data / network builtin. Alias for <code>json_decode</code>.</p>
<pre><code class="lang-perl">my $result = jd $x
# or in a pipeline:
@list |> map jd |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-je">
<h3><a class="doc-anchor" href="#doc-je">#</a> <code>je</code></h3>
<p><code>je</code> — data / network builtin. Alias for <code>json_encode</code>.</p>
<pre><code class="lang-perl">my $result = je $x
# or in a pipeline:
@list |> map je |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-join-colons">
<h3><a class="doc-anchor" href="#doc-join-colons">#</a> <code>join_colons</code></h3>
<p><code>join_colons</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = join_colons $x
# or in a pipeline:
@list |> map join_colons |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-join-commas">
<h3><a class="doc-anchor" href="#doc-join-commas">#</a> <code>join_commas</code></h3>
<p><code>join_commas</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = join_commas $x
# or in a pipeline:
@list |> map join_commas |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-join-dashes">
<h3><a class="doc-anchor" href="#doc-join-dashes">#</a> <code>join_dashes</code></h3>
<p><code>join_dashes</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = join_dashes $x
# or in a pipeline:
@list |> map join_dashes |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-join-dots">
<h3><a class="doc-anchor" href="#doc-join-dots">#</a> <code>join_dots</code></h3>
<p><code>join_dots</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = join_dots $x
# or in a pipeline:
@list |> map join_dots |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-join-lines">
<h3><a class="doc-anchor" href="#doc-join-lines">#</a> <code>join_lines</code></h3>
<p><code>join_lines</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = join_lines $x
# or in a pipeline:
@list |> map join_lines |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-join-pipes">
<h3><a class="doc-anchor" href="#doc-join-pipes">#</a> <code>join_pipes</code></h3>
<p><code>join_pipes</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = join_pipes $x
# or in a pipeline:
@list |> map join_pipes |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-join-slashes">
<h3><a class="doc-anchor" href="#doc-join-slashes">#</a> <code>join_slashes</code></h3>
<p><code>join_slashes</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = join_slashes $x
# or in a pipeline:
@list |> map join_slashes |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-join-spaces">
<h3><a class="doc-anchor" href="#doc-join-spaces">#</a> <code>join_spaces</code></h3>
<p><code>join_spaces</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = join_spaces $x
# or in a pipeline:
@list |> map join_spaces |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-join-tabs">
<h3><a class="doc-anchor" href="#doc-join-tabs">#</a> <code>join_tabs</code></h3>
<p><code>join_tabs</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = join_tabs $x
# or in a pipeline:
@list |> map join_tabs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-joules-to-cal">
<h3><a class="doc-anchor" href="#doc-joules-to-cal">#</a> <code>joules_to_cal</code></h3>
<p><code>joules_to_cal</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = joules_to_cal $input
</code></pre>
</article>
<article class="doc-entry" id="doc-json-escape">
<h3><a class="doc-anchor" href="#doc-json-escape">#</a> <code>json_escape</code></h3>
<p><code>json_escape</code> — json helpers builtin. Alias for <code>escape_json</code>.</p>
<pre><code class="lang-perl">my $result = json_escape $x
# or in a pipeline:
@list |> map json_escape |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-json-minify">
<h3><a class="doc-anchor" href="#doc-json-minify">#</a> <code>json_minify</code></h3>
<p><code>json_minify</code> — json helpers builtin.</p>
<pre><code class="lang-perl">my $result = json_minify $x
# or in a pipeline:
@list |> map json_minify |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-json-pretty">
<h3><a class="doc-anchor" href="#doc-json-pretty">#</a> <code>json_pretty</code></h3>
<p><code>json_pretty</code> — json helpers builtin.</p>
<pre><code class="lang-perl">my $result = json_pretty $x
# or in a pipeline:
@list |> map json_pretty |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-juxt2">
<h3><a class="doc-anchor" href="#doc-juxt2">#</a> <code>juxt2</code></h3>
<p><code>juxt2</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = juxt2 $x
# or in a pipeline:
@list |> map juxt2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-juxt3">
<h3><a class="doc-anchor" href="#doc-juxt3">#</a> <code>juxt3</code></h3>
<p><code>juxt3</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = juxt3 $x
# or in a pipeline:
@list |> map juxt3 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-k-to-c">
<h3><a class="doc-anchor" href="#doc-k-to-c">#</a> <code>k_to_c</code></h3>
<p><code>k_to_c</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = k_to_c $input
</code></pre>
</article>
<article class="doc-entry" id="doc-k-to-f">
<h3><a class="doc-anchor" href="#doc-k-to-f">#</a> <code>k_to_f</code></h3>
<p><code>k_to_f</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = k_to_f $input
</code></pre>
</article>
<article class="doc-entry" id="doc-kaiser">
<h3><a class="doc-anchor" href="#doc-kaiser">#</a> <code>kaiser</code></h3>
<p><code>window_kaiser($n, $beta)</code> (alias <code>kaiser</code>) — generates a Kaiser window with parameter beta controlling the tradeoff between main lobe width and sidelobe level. Beta=0 is rectangular, beta~5 is similar to Hamming.</p>
<pre><code class="lang-perl">my $w = kaiser(1024, 5.0)
</code></pre>
</article>
<article class="doc-entry" id="doc-kb-to-b">
<h3><a class="doc-anchor" href="#doc-kb-to-b">#</a> <code>kb_to_b</code></h3>
<p><code>kb_to_b</code> — unit conversions builtin. Alias for <code>kb_to_bytes</code>.</p>
<pre><code class="lang-perl">my $result = kb_to_b $input
</code></pre>
</article>
<article class="doc-entry" id="doc-kb-to-bytes">
<h3><a class="doc-anchor" href="#doc-kb-to-bytes">#</a> <code>kb_to_bytes</code></h3>
<p><code>kb_to_bytes</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = kb_to_bytes $input
</code></pre>
</article>
<article class="doc-entry" id="doc-kb-to-mb">
<h3><a class="doc-anchor" href="#doc-kb-to-mb">#</a> <code>kb_to_mb</code></h3>
<p><code>kb_to_mb</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = kb_to_mb $input
</code></pre>
</article>
<article class="doc-entry" id="doc-kcoulomb">
<h3><a class="doc-anchor" href="#doc-kcoulomb">#</a> <code>kcoulomb</code></h3>
<p><code>kcoulomb</code> — physics constants builtin. Alias for <code>coulomb_constant</code>.</p>
<pre><code class="lang-perl">my $result = kcoulomb $x
# or in a pipeline:
@list |> map kcoulomb |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-keep">
<h3><a class="doc-anchor" href="#doc-keep">#</a> <code>keep</code></h3>
<p><code>keep</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = keep $x
# or in a pipeline:
@list |> map keep |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-keep-if">
<h3><a class="doc-anchor" href="#doc-keep-if">#</a> <code>keep_if</code></h3>
<p><code>keep_if</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = keep_if $x
# or in a pipeline:
@list |> map keep_if |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kendall">
<h3><a class="doc-anchor" href="#doc-kendall">#</a> <code>kendall</code></h3>
<p><code>kendall_tau</code> (aliases <code>kendall</code>, <code>ktau</code>) computes Kendall's rank correlation coefficient (tau-b).</p>
<pre><code class="lang-perl">p ktau([1,2,3,4], [1,2,4,3]) # 0.67
</code></pre>
</article>
<article class="doc-entry" id="doc-keys-sorted">
<h3><a class="doc-anchor" href="#doc-keys-sorted">#</a> <code>keys_sorted</code></h3>
<p><code>keys_sorted</code> — hash ops (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = keys_sorted $x
# or in a pipeline:
@list |> map keys_sorted |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kg-to-lbs">
<h3><a class="doc-anchor" href="#doc-kg-to-lbs">#</a> <code>kg_to_lbs</code></h3>
<p><code>kg_to_lbs</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = kg_to_lbs $input
</code></pre>
</article>
<article class="doc-entry" id="doc-kg-to-stone">
<h3><a class="doc-anchor" href="#doc-kg-to-stone">#</a> <code>kg_to_stone</code></h3>
<p><code>kg_to_stone</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = kg_to_stone $input
</code></pre>
</article>
<article class="doc-entry" id="doc-khinchin">
<h3><a class="doc-anchor" href="#doc-khinchin">#</a> <code>khinchin</code></h3>
<p><code>khinchin</code> — math constants builtin. Alias for <code>khinchin_constant</code>.</p>
<pre><code class="lang-perl">my $result = khinchin $x
# or in a pipeline:
@list |> map khinchin |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-khinchin-constant">
<h3><a class="doc-anchor" href="#doc-khinchin-constant">#</a> <code>khinchin_constant</code></h3>
<p><code>khinchin_constant</code> — math constants builtin.</p>
<pre><code class="lang-perl">my $result = khinchin_constant $x
# or in a pipeline:
@list |> map khinchin_constant |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kinetic-energy">
<h3><a class="doc-anchor" href="#doc-kinetic-energy">#</a> <code>kinetic_energy</code></h3>
<p><code>kinetic_energy</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = kinetic_energy $x
# or in a pipeline:
@list |> map kinetic_energy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-km-to-miles">
<h3><a class="doc-anchor" href="#doc-km-to-miles">#</a> <code>km_to_miles</code></h3>
<p><code>km_to_miles</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = km_to_miles $input
</code></pre>
</article>
<article class="doc-entry" id="doc-kmeans">
<h3><a class="doc-anchor" href="#doc-kmeans">#</a> <code>kmeans</code></h3>
<p><code>kmeans</code> — k-means clustering (Lloyd's algorithm). Takes array of points and k. Returns cluster assignments. Like R's kmeans().</p>
<pre><code class="lang-perl">my @clusters = @{kmeans([[0,0],[1,0],[10,10],[11,10]], 2)}
# [0,0,1,1] — two clusters
</code></pre>
</article>
<article class="doc-entry" id="doc-kp">
<h3><a class="doc-anchor" href="#doc-kp">#</a> <code>kp</code></h3>
<p><code>kp</code> — algebraic match builtin. Alias for <code>keep</code>.</p>
<pre><code class="lang-perl">my $result = kp $x
# or in a pipeline:
@list |> map kp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ks">
<h3><a class="doc-anchor" href="#doc-ks">#</a> <code>ks</code></h3>
<p><code>ks_test</code> (alias <code>ks</code>) — two-sample Kolmogorov-Smirnov test. Returns D statistic (max CDF difference). Like R's ks.test().</p>
<pre><code class="lang-perl">my $D = ks([1,2,3,4,5], [2,3,4,5,6]) # small D = similar
</code></pre>
</article>
<article class="doc-entry" id="doc-kth-largest">
<h3><a class="doc-anchor" href="#doc-kth-largest">#</a> <code>kth_largest</code></h3>
<p><code>kth_largest</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = kth_largest $x
# or in a pipeline:
@list |> map kth_largest |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kth-smallest">
<h3><a class="doc-anchor" href="#doc-kth-smallest">#</a> <code>kth_smallest</code></h3>
<p><code>kth_smallest</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = kth_smallest $x
# or in a pipeline:
@list |> map kth_smallest |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kthl">
<h3><a class="doc-anchor" href="#doc-kthl">#</a> <code>kthl</code></h3>
<p><code>kthl</code> — extended stdlib batch 3 builtin. Alias for <code>kth_largest</code>.</p>
<pre><code class="lang-perl">my $result = kthl $x
# or in a pipeline:
@list |> map kthl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kths">
<h3><a class="doc-anchor" href="#doc-kths">#</a> <code>kths</code></h3>
<p><code>kths</code> — extended stdlib batch 3 builtin. Alias for <code>kth_smallest</code>.</p>
<pre><code class="lang-perl">my $result = kths $x
# or in a pipeline:
@list |> map kths |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kurt">
<h3><a class="doc-anchor" href="#doc-kurt">#</a> <code>kurt</code></h3>
<p><code>kurt</code> — math / numeric (uncategorized batch) builtin. Alias for <code>kurtosis</code>.</p>
<pre><code class="lang-perl">my $result = kurt $x
# or in a pipeline:
@list |> map kurt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-kurtosis">
<h3><a class="doc-anchor" href="#doc-kurtosis">#</a> <code>kurtosis</code></h3>
<p><code>kurtosis</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = kurtosis $x
# or in a pipeline:
@list |> map kurtosis |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lagrange">
<h3><a class="doc-anchor" href="#doc-lagrange">#</a> <code>lagrange</code></h3>
<p><code>lagrange_interp</code> (aliases <code>lagrange</code>, <code>linterp</code>) performs Lagrange polynomial interpolation. Takes xs, ys, and a query point x.</p>
<pre><code class="lang-perl">p lagrange([0,1,2], [0,1,4], 1.5) # 2.25
</code></pre>
</article>
<article class="doc-entry" id="doc-lambert-w">
<h3><a class="doc-anchor" href="#doc-lambert-w">#</a> <code>lambert_w</code></h3>
<p><code>lambert_w</code> (aliases <code>lambertw</code>, <code>productlog</code>) computes the Lambert W function (principal branch): the inverse of f(w) = w·e^w.</p>
<pre><code class="lang-perl">p lambertw(1) # 0.5671 (Omega constant)
p lambertw(exp(1)) # 1.0
</code></pre>
</article>
<article class="doc-entry" id="doc-laplace-pdf">
<h3><a class="doc-anchor" href="#doc-laplace-pdf">#</a> <code>laplace_pdf</code></h3>
<p><code>laplace_pdf</code> (alias <code>laplacepdf</code>) evaluates the Laplace distribution PDF at x with location mu and scale b.</p>
<pre><code class="lang-perl">p laplacepdf(0, 0, 1) # 0.5 (peak)
</code></pre>
</article>
<article class="doc-entry" id="doc-last-arg">
<h3><a class="doc-anchor" href="#doc-last-arg">#</a> <code>last_arg</code></h3>
<p><code>last_arg</code> — functional primitives builtin.</p>
<pre><code class="lang-perl">my $result = last_arg $x
# or in a pipeline:
@list |> map last_arg |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-last-clj">
<h3><a class="doc-anchor" href="#doc-last-clj">#</a> <code>last_clj</code></h3>
<p><code>last_clj</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = last_clj $x
# or in a pipeline:
@list |> map last_clj |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-last-elem">
<h3><a class="doc-anchor" href="#doc-last-elem">#</a> <code>last_elem</code></h3>
<p><code>last_elem</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = last_elem $x
# or in a pipeline:
@list |> map last_elem |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-last-eq">
<h3><a class="doc-anchor" href="#doc-last-eq">#</a> <code>last_eq</code></h3>
<p><code>last_eq</code> — collection (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = last_eq $x
# or in a pipeline:
@list |> map last_eq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-last-index-of">
<h3><a class="doc-anchor" href="#doc-last-index-of">#</a> <code>last_index_of</code></h3>
<p><code>last_index_of</code> — collection (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = last_index_of $x
# or in a pipeline:
@list |> map last_index_of |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-last-word">
<h3><a class="doc-anchor" href="#doc-last-word">#</a> <code>last_word</code></h3>
<p><code>last_word</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = last_word $x
# or in a pipeline:
@list |> map last_word |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lastc">
<h3><a class="doc-anchor" href="#doc-lastc">#</a> <code>lastc</code></h3>
<p><code>lastc</code> — algebraic match builtin. Alias for <code>last_clj</code>.</p>
<pre><code class="lang-perl">my $result = lastc $x
# or in a pipeline:
@list |> map lastc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lbf-to-newtons">
<h3><a class="doc-anchor" href="#doc-lbf-to-newtons">#</a> <code>lbf_to_newtons</code></h3>
<p><code>lbf_to_newtons</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = lbf_to_newtons $input
</code></pre>
</article>
<article class="doc-entry" id="doc-lbound">
<h3><a class="doc-anchor" href="#doc-lbound">#</a> <code>lbound</code></h3>
<p><code>lbound</code> — extended stdlib builtin. Alias for <code>lower_bound</code>.</p>
<pre><code class="lang-perl">my $result = lbound $x
# or in a pipeline:
@list |> map lbound |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lbs-to-kg">
<h3><a class="doc-anchor" href="#doc-lbs-to-kg">#</a> <code>lbs_to_kg</code></h3>
<p><code>lbs_to_kg</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = lbs_to_kg $input
</code></pre>
</article>
<article class="doc-entry" id="doc-lc-lines">
<h3><a class="doc-anchor" href="#doc-lc-lines">#</a> <code>lc_lines</code></h3>
<p><code>lc_lines</code> — trivial string ops builtin. Alias for <code>line_count</code>.</p>
<pre><code class="lang-perl">my $result = lc_lines $x
# or in a pipeline:
@list |> map lc_lines |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lcm">
<h3><a class="doc-anchor" href="#doc-lcm">#</a> <code>lcm</code></h3>
<p><code>lcm</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = lcm $x
# or in a pipeline:
@list |> map lcm |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lcontract">
<h3><a class="doc-anchor" href="#doc-lcontract">#</a> <code>lcontract</code></h3>
<p><code>length_contraction($proper_length, $velocity)</code> (alias <code>lcontract</code>) — contracted length L = L₀ × √(1-v²/c²).</p>
<pre><code class="lang-perl">p lcontract(1, 0.99 * 3e8) # ~0.14 m (1m at 99% c)
</code></pre>
</article>
<article class="doc-entry" id="doc-lcount">
<h3><a class="doc-anchor" href="#doc-lcount">#</a> <code>lcount</code></h3>
<p><code>lcount</code> — extended stdlib batch 3 builtin. Alias for <code>count_lines</code>.</p>
<pre><code class="lang-perl">my $result = lcount $x
# or in a pipeline:
@list |> map lcount |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lcp">
<h3><a class="doc-anchor" href="#doc-lcp">#</a> <code>lcp</code></h3>
<p><code>lcp</code> — string (batch 2) builtin. Alias for <code>longest_common_prefix</code>.</p>
<pre><code class="lang-perl">my $result = lcp $x
# or in a pipeline:
@list |> map lcp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lcseq">
<h3><a class="doc-anchor" href="#doc-lcseq">#</a> <code>lcseq</code></h3>
<p><code>lcseq</code> — extended stdlib batch 3 builtin. Alias for <code>longest_common_subsequence</code>.</p>
<pre><code class="lang-perl">my $result = lcseq $x
# or in a pipeline:
@list |> map lcseq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lcsub">
<h3><a class="doc-anchor" href="#doc-lcsub">#</a> <code>lcsub</code></h3>
<p><code>lcsub</code> — extended stdlib batch 3 builtin. Alias for <code>longest_common_substring</code>.</p>
<pre><code class="lang-perl">my $result = lcsub $x
# or in a pipeline:
@list |> map lcsub |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ldec">
<h3><a class="doc-anchor" href="#doc-ldec">#</a> <code>ldec</code></h3>
<p><code>ldec</code> — extended stdlib batch 3 builtin. Alias for <code>longest_decreasing</code>.</p>
<pre><code class="lang-perl">my $result = ldec $x
# or in a pipeline:
@list |> map ldec |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-leading-zeros">
<h3><a class="doc-anchor" href="#doc-leading-zeros">#</a> <code>leading_zeros</code></h3>
<p><code>leading_zeros</code> — base conversion builtin.</p>
<pre><code class="lang-perl">my $result = leading_zeros $x
# or in a pipeline:
@list |> map leading_zeros |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-leaky-relu">
<h3><a class="doc-anchor" href="#doc-leaky-relu">#</a> <code>leaky_relu</code></h3>
<p><code>leaky_relu</code> (alias <code>lrelu</code>) applies Leaky ReLU: x if x≥0, alpha*x otherwise (default alpha=0.01).</p>
<pre><code class="lang-perl">p lrelu(5) # 5
p lrelu(-5) # -0.05
p lrelu(-5, 0.1) # -0.5
</code></pre>
</article>
<article class="doc-entry" id="doc-least-common">
<h3><a class="doc-anchor" href="#doc-least-common">#</a> <code>least_common</code></h3>
<p><code>least_common</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = least_common $x
# or in a pipeline:
@list |> map least_common |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-leet">
<h3><a class="doc-anchor" href="#doc-leet">#</a> <code>leet</code></h3>
<p><code>leet</code> — string processing (uncategorized batch) builtin. Alias for <code>leetspeak</code>.</p>
<pre><code class="lang-perl">my $result = leet $x
# or in a pipeline:
@list |> map leet |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-leetspeak">
<h3><a class="doc-anchor" href="#doc-leetspeak">#</a> <code>leetspeak</code></h3>
<p><code>leetspeak</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = leetspeak $x
# or in a pipeline:
@list |> map leetspeak |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-left-str">
<h3><a class="doc-anchor" href="#doc-left-str">#</a> <code>left_str</code></h3>
<p><code>left_str</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = left_str $x
# or in a pipeline:
@list |> map left_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-length-each">
<h3><a class="doc-anchor" href="#doc-length-each">#</a> <code>length_each</code></h3>
<p><code>length_each</code> — trivial numeric helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = length_each $x
# or in a pipeline:
@list |> map length_each |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lens-power">
<h3><a class="doc-anchor" href="#doc-lens-power">#</a> <code>lens_power</code></h3>
<p><code>lens_power</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = lens_power $x
# or in a pipeline:
@list |> map lens_power |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lerp">
<h3><a class="doc-anchor" href="#doc-lerp">#</a> <code>lerp</code></h3>
<p><code>lerp($a, $b, $t)</code> — linear interpolation between a and b. When t=0 returns a, t=1 returns b, t=0.5 returns midpoint.</p>
<pre><code class="lang-perl">p lerp(0, 100, 0.5) # 50
p lerp(10, 20, 0.25) # 12.5
# Animation: smoothly transition between values
for my $t (0..10) { p lerp($start, $end, $t/10) }
</code></pre>
</article>
<article class="doc-entry" id="doc-less">
<h3><a class="doc-anchor" href="#doc-less">#</a> <code>less</code></h3>
<p><code>LIST |> pager</code> / <code>pager LIST</code> — pipe each element (one per line) into the user's <code>$PAGER</code> (default <code>less -R</code>; falls back to <code>more</code>, then plain stdout). Bypasses the pager when stdout isn't a TTY so pipelines like <code>stryke '... |> pager' | grep</code> still compose.</p>
<p>Blocks until the user quits the pager; returns <code>undef</code>.</p>
<p>Aliases: <code>pager</code>, <code>pg</code>, <code>less</code>.</p>
<pre><code class="lang-perl"># browse every callable spelling interactively
keys %all |> sort |> pager
# filter the reference for parallel ops
keys %b |> grep { $b{$_} eq "parallel" } |> pager
# whole file, one screen at a time
slurp("README.md") |> pager
</code></pre>
</article>
<article class="doc-entry" id="doc-letters-lc">
<h3><a class="doc-anchor" href="#doc-letters-lc">#</a> <code>letters_lc</code></h3>
<p><code>letters_lc</code> extracts only lowercase letters from a string.</p>
<pre><code class="lang-perl">p join "", letters_lc("Hello World 123") # elloorld
</code></pre>
</article>
<article class="doc-entry" id="doc-letters-uc">
<h3><a class="doc-anchor" href="#doc-letters-uc">#</a> <code>letters_uc</code></h3>
<p><code>letters_uc</code> extracts only uppercase letters from a string.</p>
<pre><code class="lang-perl">p join "", letters_uc("Hello World 123") # HW
</code></pre>
</article>
<article class="doc-entry" id="doc-lev">
<h3><a class="doc-anchor" href="#doc-lev">#</a> <code>lev</code></h3>
<p><code>lev</code> — extended stdlib builtin. Alias for <code>levenshtein</code>.</p>
<pre><code class="lang-perl">my $result = lev $x
# or in a pipeline:
@list |> map lev |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-levenshtein">
<h3><a class="doc-anchor" href="#doc-levenshtein">#</a> <code>levenshtein</code></h3>
<p><code>levenshtein</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = levenshtein $x
# or in a pipeline:
@list |> map levenshtein |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lfrm">
<h3><a class="doc-anchor" href="#doc-lfrm">#</a> <code>lfrm</code></h3>
<p><code>lfrm</code> — go/general functional utilities builtin. Alias for <code>lines_from</code>.</p>
<pre><code class="lang-perl">my $result = lfrm $x
# or in a pipeline:
@list |> map lfrm |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-light-year">
<h3><a class="doc-anchor" href="#doc-light-year">#</a> <code>light_year</code></h3>
<p><code>light_year</code> (alias <code>ly</code>) — ly ≈ 9.461×10¹⁵ m. Distance light travels in one year.</p>
<pre><code class="lang-perl">p ly # 9.4607304725808e15 m
p ly / au # ~63241 AU
</code></pre>
</article>
<article class="doc-entry" id="doc-linc">
<h3><a class="doc-anchor" href="#doc-linc">#</a> <code>linc</code></h3>
<p><code>linc</code> — extended stdlib batch 3 builtin. Alias for <code>longest_increasing</code>.</p>
<pre><code class="lang-perl">my $result = linc $x
# or in a pipeline:
@list |> map linc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-line-count">
<h3><a class="doc-anchor" href="#doc-line-count">#</a> <code>line_count</code></h3>
<p><code>line_count</code> — trivial string ops builtin.</p>
<pre><code class="lang-perl">my $result = line_count $x
# or in a pipeline:
@list |> map line_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-line-intersection">
<h3><a class="doc-anchor" href="#doc-line-intersection">#</a> <code>line_intersection</code></h3>
<p><code>line_intersection($x1, $y1, $x2, $y2, $x3, $y3, $x4, $y4)</code> — finds the intersection point of two lines defined by points (x1,y1)-(x2,y2) and (x3,y3)-(x4,y4). Returns [$x, $y] or undef if parallel.</p>
<pre><code class="lang-perl">my $pt = line_intersection(0, 0, 1, 1, 0, 1, 1, 0)
p @$pt # (0.5, 0.5)
</code></pre>
</article>
<article class="doc-entry" id="doc-linear-regression">
<h3><a class="doc-anchor" href="#doc-linear-regression">#</a> <code>linear_regression</code></h3>
<p><code>linear_regression</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = linear_regression $x
# or in a pipeline:
@list |> map linear_regression |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-linear-search">
<h3><a class="doc-anchor" href="#doc-linear-search">#</a> <code>linear_search</code></h3>
<p><code>linear_search</code> — collection (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = linear_search $x
# or in a pipeline:
@list |> map linear_search |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lineintr">
<h3><a class="doc-anchor" href="#doc-lineintr">#</a> <code>lineintr</code></h3>
<p><code>lineintr</code> — geometry (extended) builtin. Alias for <code>line_intersection</code>.</p>
<pre><code class="lang-perl">my $result = lineintr $x
# or in a pipeline:
@list |> map lineintr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lines-from">
<h3><a class="doc-anchor" href="#doc-lines-from">#</a> <code>lines_from</code></h3>
<p><code>lines_from</code> — go/general functional utilities builtin.</p>
<pre><code class="lang-perl">my $result = lines_from $x
# or in a pipeline:
@list |> map lines_from |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-linreg">
<h3><a class="doc-anchor" href="#doc-linreg">#</a> <code>linreg</code></h3>
<p><code>linreg</code> — math / numeric (uncategorized batch) builtin. Alias for <code>linear_regression</code>.</p>
<pre><code class="lang-perl">my $result = linreg $x
# or in a pipeline:
@list |> map linreg |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-linspace">
<h3><a class="doc-anchor" href="#doc-linspace">#</a> <code>linspace</code></h3>
<p><code>linspace</code> — matrix / linear algebra builtin.</p>
<pre><code class="lang-perl">my $result = linspace $x
# or in a pipeline:
@list |> map linspace |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-list-compact">
<h3><a class="doc-anchor" href="#doc-list-compact">#</a> <code>list_compact</code></h3>
<p><code>list_compact</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = list_compact $x
# or in a pipeline:
@list |> map list_compact |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-list-count">
<h3><a class="doc-anchor" href="#doc-list-count">#</a> <code>list_count</code></h3>
<p><code>list_count</code> (alias <code>list_size</code>) returns the total number of elements after flattening a nested list structure. Unlike <code>count</code> which returns the top-level element count, <code>list_count</code> recursively descends into array references and counts only leaf values. This is useful when you have a list of lists and need to know the total number of individual items rather than the number of sublists.</p>
<pre><code class="lang-perl">my @nested = ([1, 2], [3, 4, 5], [6])
p list_count @nested # 6
my @deep = ([1, [2, 3]], [4])
p list_size @deep # 4
p list_count 1, 2, 3 # 3 (flat list works too)
</code></pre>
</article>
<article class="doc-entry" id="doc-list-difference">
<h3><a class="doc-anchor" href="#doc-list-difference">#</a> <code>list_difference</code></h3>
<p><code>list_difference</code> — collection (batch 2) builtin. Alias for <code>array_difference</code>.</p>
<pre><code class="lang-perl">my $result = list_difference $x
# or in a pipeline:
@list |> map list_difference |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-list-eq">
<h3><a class="doc-anchor" href="#doc-list-eq">#</a> <code>list_eq</code></h3>
<p><code>list_eq</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = list_eq $x
# or in a pipeline:
@list |> map list_eq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-list-flatten-deep">
<h3><a class="doc-anchor" href="#doc-list-flatten-deep">#</a> <code>list_flatten_deep</code></h3>
<p><code>list_flatten_deep</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = list_flatten_deep $x
# or in a pipeline:
@list |> map list_flatten_deep |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-list-intersection">
<h3><a class="doc-anchor" href="#doc-list-intersection">#</a> <code>list_intersection</code></h3>
<p><code>list_intersection</code> — collection (batch 2) builtin. Alias for <code>array_intersection</code>.</p>
<pre><code class="lang-perl">my $result = list_intersection $x
# or in a pipeline:
@list |> map list_intersection |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-list-reverse">
<h3><a class="doc-anchor" href="#doc-list-reverse">#</a> <code>list_reverse</code></h3>
<p><code>list_reverse</code> — file stat / path builtin. Alias for <code>reverse_list</code>.</p>
<pre><code class="lang-perl">my $result = list_reverse $x
# or in a pipeline:
@list |> map list_reverse |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-list-union">
<h3><a class="doc-anchor" href="#doc-list-union">#</a> <code>list_union</code></h3>
<p><code>list_union</code> — collection (batch 2) builtin. Alias for <code>array_union</code>.</p>
<pre><code class="lang-perl">my $result = list_union $x
# or in a pipeline:
@list |> map list_union |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-liters-to-gallons">
<h3><a class="doc-anchor" href="#doc-liters-to-gallons">#</a> <code>liters_to_gallons</code></h3>
<p><code>liters_to_gallons</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = liters_to_gallons $input
</code></pre>
</article>
<article class="doc-entry" id="doc-liters-to-ml">
<h3><a class="doc-anchor" href="#doc-liters-to-ml">#</a> <code>liters_to_ml</code></h3>
<p><code>liters_to_ml</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = liters_to_ml $input
</code></pre>
</article>
<article class="doc-entry" id="doc-ljt">
<h3><a class="doc-anchor" href="#doc-ljt">#</a> <code>ljt</code></h3>
<p><code>ljt</code> — extended stdlib builtin. Alias for <code>ljust_text</code>.</p>
<pre><code class="lang-perl">my $result = ljt $x
# or in a pipeline:
@list |> map ljt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ljust">
<h3><a class="doc-anchor" href="#doc-ljust">#</a> <code>ljust</code></h3>
<p><code>ljust</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = ljust $x
# or in a pipeline:
@list |> map ljust |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ljust-text">
<h3><a class="doc-anchor" href="#doc-ljust-text">#</a> <code>ljust_text</code></h3>
<p><code>ljust_text</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = ljust_text $x
# or in a pipeline:
@list |> map ljust_text |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lkpa">
<h3><a class="doc-anchor" href="#doc-lkpa">#</a> <code>lkpa</code></h3>
<p><code>lkpa</code> — haskell list functions builtin. Alias for <code>lookup_assoc</code>.</p>
<pre><code class="lang-perl">my $result = lkpa $x
# or in a pipeline:
@list |> map lkpa |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lm">
<h3><a class="doc-anchor" href="#doc-lm">#</a> <code>lm</code></h3>
<p><code>lm_fit</code> (alias <code>lm</code>) — simple linear regression. Returns hash with intercept, slope, r_squared, residuals, fitted. Like R's lm().</p>
<pre><code class="lang-perl">my %m = %{lm([1,2,3,4,5], [2,4,5,4,5])}
p $m{slope} # slope
p $m{r_squared} # R²
</code></pre>
</article>
<article class="doc-entry" id="doc-ln10">
<h3><a class="doc-anchor" href="#doc-ln10">#</a> <code>ln10</code></h3>
<p><code>ln10</code> — math / physics constants builtin.</p>
<pre><code class="lang-perl">my $result = ln10 $x
# or in a pipeline:
@list |> map ln10 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ln2">
<h3><a class="doc-anchor" href="#doc-ln2">#</a> <code>ln2</code></h3>
<p><code>ln2</code> — math / physics constants builtin.</p>
<pre><code class="lang-perl">my $result = ln2 $x
# or in a pipeline:
@list |> map ln2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lnormpdf">
<h3><a class="doc-anchor" href="#doc-lnormpdf">#</a> <code>lnormpdf</code></h3>
<p><code>lognormal_pdf</code> (alias <code>lnormpdf</code>) evaluates the log-normal distribution PDF at x with parameters mu and sigma.</p>
<pre><code class="lang-perl">p lnormpdf(1.0, 0, 1) # LogN(0,1) at x=1
</code></pre>
</article>
<article class="doc-entry" id="doc-lns">
<h3><a class="doc-anchor" href="#doc-lns">#</a> <code>lns</code></h3>
<p><code>lns</code> — math / numeric (uncategorized batch) builtin. Alias for <code>look_and_say</code>.</p>
<pre><code class="lang-perl">my $result = lns $x
# or in a pipeline:
@list |> map lns |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-load-avg">
<h3><a class="doc-anchor" href="#doc-load-avg">#</a> <code>load_avg</code></h3>
<p><code>load_avg</code> — system load averages as a 3-element arrayref <code>[1min, 5min, 15min]</code>. Uses <code>getloadavg()</code> on unix. Returns <code>undef</code> on unsupported platforms.</p>
<pre><code class="lang-perl">my $la = load_avg
p "1m=$la->[0] 5m=$la->[1] 15m=$la->[2]"
load_avg |> spark |> p # sparkline of load
</code></pre>
</article>
<article class="doc-entry" id="doc-loess">
<h3><a class="doc-anchor" href="#doc-loess">#</a> <code>loess</code></h3>
<p><code>lowess</code> (alias <code>loess</code>) — locally-weighted scatterplot smoothing (LOWESS/LOESS). Returns smoothed Y values with tricube weighting.</p>
<pre><code class="lang-perl">my @smooth = @{lowess([1,2,3,4,5], [2,1,4,3,5])}
</code></pre>
</article>
<article class="doc-entry" id="doc-log10">
<h3><a class="doc-anchor" href="#doc-log10">#</a> <code>log10</code></h3>
<p><code>log10</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = log10 $x
# or in a pipeline:
@list |> map log10 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-log2">
<h3><a class="doc-anchor" href="#doc-log2">#</a> <code>log2</code></h3>
<p><code>log2</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = log2 $x
# or in a pipeline:
@list |> map log2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-log-base">
<h3><a class="doc-anchor" href="#doc-log-base">#</a> <code>log_base</code></h3>
<p><code>log_base</code> — math functions builtin.</p>
<pre><code class="lang-perl">my $result = log_base $x
# or in a pipeline:
@list |> map log_base |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-log-with-base">
<h3><a class="doc-anchor" href="#doc-log-with-base">#</a> <code>log_with_base</code></h3>
<p><code>log_with_base</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = log_with_base $x
# or in a pipeline:
@list |> map log_with_base |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-logb">
<h3><a class="doc-anchor" href="#doc-logb">#</a> <code>logb</code></h3>
<p><code>logb</code> — extended stdlib builtin. Alias for <code>log_with_base</code>.</p>
<pre><code class="lang-perl">my $result = logb $x
# or in a pipeline:
@list |> map logb |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-longest">
<h3><a class="doc-anchor" href="#doc-longest">#</a> <code>longest</code></h3>
<p><code>longest</code> — collection (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = longest $x
# or in a pipeline:
@list |> map longest |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-longest-common-prefix">
<h3><a class="doc-anchor" href="#doc-longest-common-prefix">#</a> <code>longest_common_prefix</code></h3>
<p><code>longest_common_prefix</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = longest_common_prefix $x
# or in a pipeline:
@list |> map longest_common_prefix |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-longest-common-subsequence">
<h3><a class="doc-anchor" href="#doc-longest-common-subsequence">#</a> <code>longest_common_subsequence</code></h3>
<p><code>longest_common_subsequence</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = longest_common_subsequence $x
# or in a pipeline:
@list |> map longest_common_subsequence |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-longest-common-substring">
<h3><a class="doc-anchor" href="#doc-longest-common-substring">#</a> <code>longest_common_substring</code></h3>
<p><code>longest_common_substring</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = longest_common_substring $x
# or in a pipeline:
@list |> map longest_common_substring |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-longest-decreasing">
<h3><a class="doc-anchor" href="#doc-longest-decreasing">#</a> <code>longest_decreasing</code></h3>
<p><code>longest_decreasing</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = longest_decreasing $x
# or in a pipeline:
@list |> map longest_decreasing |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-longest-increasing">
<h3><a class="doc-anchor" href="#doc-longest-increasing">#</a> <code>longest_increasing</code></h3>
<p><code>longest_increasing</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = longest_increasing $x
# or in a pipeline:
@list |> map longest_increasing |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-longest-run">
<h3><a class="doc-anchor" href="#doc-longest-run">#</a> <code>longest_run</code></h3>
<p><code>longest_run</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = longest_run $x
# or in a pipeline:
@list |> map longest_run |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-look-and-say">
<h3><a class="doc-anchor" href="#doc-look-and-say">#</a> <code>look_and_say</code></h3>
<p><code>look_and_say</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = look_and_say $x
# or in a pipeline:
@list |> map look_and_say |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lookup-assoc">
<h3><a class="doc-anchor" href="#doc-lookup-assoc">#</a> <code>lookup_assoc</code></h3>
<p><code>lookup_assoc</code> — haskell list functions builtin.</p>
<pre><code class="lang-perl">my $result = lookup_assoc $x
# or in a pipeline:
@list |> map lookup_assoc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lorentz">
<h3><a class="doc-anchor" href="#doc-lorentz">#</a> <code>lorentz</code></h3>
<p><code>lorentz_factor($velocity)</code> (alias <code>lorentz</code>) — relativistic gamma factor γ = 1/√(1-v²/c²). Returns infinity at v ≥ c.</p>
<pre><code class="lang-perl">p lorentz(0) # 1 (at rest)
p lorentz(0.9 * 3e8) # ~2.29 (at 90% speed of light)
</code></pre>
</article>
<article class="doc-entry" id="doc-lorenz">
<h3><a class="doc-anchor" href="#doc-lorenz">#</a> <code>lorenz</code></h3>
<p><code>lorenz_curve(@data)</code> (alias <code>lorenz</code>) — computes the Lorenz curve as an arrayref of [cumulative_share_of_population, cumulative_share_of_wealth] pairs. Used to visualize inequality. The diagonal represents perfect equality.</p>
<pre><code class="lang-perl">my $curve = lorenz(10, 20, 30, 40)
for my $pt (@$curve) {
p "$pt->[0], $pt->[1]"
}
</code></pre>
</article>
<article class="doc-entry" id="doc-lower-bound">
<h3><a class="doc-anchor" href="#doc-lower-bound">#</a> <code>lower_bound</code></h3>
<p><code>lower_bound</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = lower_bound $x
# or in a pipeline:
@list |> map lower_bound |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lowercase">
<h3><a class="doc-anchor" href="#doc-lowercase">#</a> <code>lowercase</code></h3>
<p><code>lowercase</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = lowercase $x
# or in a pipeline:
@list |> map lowercase |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lowpass-filter">
<h3><a class="doc-anchor" href="#doc-lowpass-filter">#</a> <code>lowpass_filter</code></h3>
<p><code>lowpass_filter(\@signal, $cutoff)</code> (alias <code>lpf</code>) — applies a simple low-pass filter to remove high-frequency components. Cutoff is normalized (0-1). Uses exponential moving average.</p>
<pre><code class="lang-perl">my @noisy = map { sin($_/10) + rand(0.2) } 1..100
my $smooth = lpf(\@noisy, 0.1)
</code></pre>
</article>
<article class="doc-entry" id="doc-lpad">
<h3><a class="doc-anchor" href="#doc-lpad">#</a> <code>lpad</code></h3>
<p><code>lpad</code> — trivial string ops builtin. Alias for <code>pad_left</code>.</p>
<pre><code class="lang-perl">my $result = lpad $x
# or in a pipeline:
@list |> map lpad |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lplanck">
<h3><a class="doc-anchor" href="#doc-lplanck">#</a> <code>lplanck</code></h3>
<p><code>planck_length</code> (alias <code>lplanck</code>) — lP ≈ 1.616×10⁻³⁵ m. Smallest meaningful length in quantum mechanics.</p>
<pre><code class="lang-perl">p lplanck # 1.616255e-35 m
</code></pre>
</article>
<article class="doc-entry" id="doc-lru-new">
<h3><a class="doc-anchor" href="#doc-lru-new">#</a> <code>lru_new</code></h3>
<p><code>lru_new</code> — data structure helpers builtin.</p>
<pre><code class="lang-perl">my $result = lru_new $x
# or in a pipeline:
@list |> map lru_new |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lrun">
<h3><a class="doc-anchor" href="#doc-lrun">#</a> <code>lrun</code></h3>
<p><code>lrun</code> — extended stdlib batch 3 builtin. Alias for <code>longest_run</code>.</p>
<pre><code class="lang-perl">my $result = lrun $x
# or in a pipeline:
@list |> map lrun |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lsearch">
<h3><a class="doc-anchor" href="#doc-lsearch">#</a> <code>lsearch</code></h3>
<p><code>lsearch</code> — collection (batch 2) builtin. Alias for <code>linear_search</code>.</p>
<pre><code class="lang-perl">my $result = lsearch $x
# or in a pipeline:
@list |> map lsearch |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lstat">
<h3><a class="doc-anchor" href="#doc-lstat">#</a> <code>lstat</code></h3>
<p><code>lstat</code> — filesystem builtin.</p>
<pre><code class="lang-perl">my $result = lstat $x
# or in a pipeline:
@list |> map lstat |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lucas">
<h3><a class="doc-anchor" href="#doc-lucas">#</a> <code>lucas</code></h3>
<p><code>lucas</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = lucas $x
# or in a pipeline:
@list |> map lucas |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-luhn">
<h3><a class="doc-anchor" href="#doc-luhn">#</a> <code>luhn</code></h3>
<p><code>luhn</code> — math / numeric (uncategorized batch) builtin. Alias for <code>luhn_check</code>.</p>
<pre><code class="lang-perl">my $result = luhn $x
# or in a pipeline:
@list |> map luhn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-luhn-check">
<h3><a class="doc-anchor" href="#doc-luhn-check">#</a> <code>luhn_check</code></h3>
<p><code>luhn_check</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = luhn_check $x
# or in a pipeline:
@list |> map luhn_check |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-lz">
<h3><a class="doc-anchor" href="#doc-lz">#</a> <code>lz</code></h3>
<p><code>lz</code> — base conversion builtin. Alias for <code>leading_zeros</code>.</p>
<pre><code class="lang-perl">my $result = lz $x
# or in a pipeline:
@list |> map lz |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-m5">
<h3><a class="doc-anchor" href="#doc-m5">#</a> <code>m5</code></h3>
<p><code>m5</code> — crypto / encoding builtin. Alias for <code>md5</code>.</p>
<pre><code class="lang-perl">my $result = m5 $x
# or in a pipeline:
@list |> map m5 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-m-to-feet">
<h3><a class="doc-anchor" href="#doc-m-to-feet">#</a> <code>m_to_feet</code></h3>
<p><code>m_to_feet</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = m_to_feet $input
</code></pre>
</article>
<article class="doc-entry" id="doc-m-to-miles">
<h3><a class="doc-anchor" href="#doc-m-to-miles">#</a> <code>m_to_miles</code></h3>
<p><code>m_to_miles</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = m_to_miles $input
</code></pre>
</article>
<article class="doc-entry" id="doc-m-to-s">
<h3><a class="doc-anchor" href="#doc-m-to-s">#</a> <code>m_to_s</code></h3>
<p><code>m_to_s</code> — unit conversions builtin. Alias for <code>minutes_to_seconds</code>.</p>
<pre><code class="lang-perl">my $result = m_to_s $input
</code></pre>
</article>
<article class="doc-entry" id="doc-m-to-yards">
<h3><a class="doc-anchor" href="#doc-m-to-yards">#</a> <code>m_to_yards</code></h3>
<p><code>m_to_yards</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = m_to_yards $input
</code></pre>
</article>
<article class="doc-entry" id="doc-mac-duration">
<h3><a class="doc-anchor" href="#doc-mac-duration">#</a> <code>mac_duration</code></h3>
<p><code>bond_duration</code> (alias <code>mac_duration</code>) computes Macaulay duration — the weighted-average time to receive cash flows.</p>
<pre><code class="lang-perl">my $dur = bond_duration([5,5,5,105], 0.05) # ≈ 3.72 years
</code></pre>
</article>
<article class="doc-entry" id="doc-macdur">
<h3><a class="doc-anchor" href="#doc-macdur">#</a> <code>macdur</code></h3>
<p><code>macdur</code> — finance (extended) builtin. Alias for <code>duration</code>.</p>
<pre><code class="lang-perl">my $result = macdur $x
# or in a pipeline:
@list |> map macdur |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mad">
<h3><a class="doc-anchor" href="#doc-mad">#</a> <code>mad</code></h3>
<p><code>mad</code> — math / numeric (uncategorized batch) builtin. Alias for <code>median_absolute_deviation</code>.</p>
<pre><code class="lang-perl">my $result = mad $x
# or in a pipeline:
@list |> map mad |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-madd">
<h3><a class="doc-anchor" href="#doc-madd">#</a> <code>madd</code></h3>
<p><code>madd</code> — extended stdlib builtin. Alias for <code>matrix_add</code>.</p>
<pre><code class="lang-perl">my $result = madd $x
# or in a pipeline:
@list |> map madd |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mae">
<h3><a class="doc-anchor" href="#doc-mae">#</a> <code>mae</code></h3>
<p><code>mae</code> — math functions builtin.</p>
<pre><code class="lang-perl">my $result = mae $x
# or in a pipeline:
@list |> map mae |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mag">
<h3><a class="doc-anchor" href="#doc-mag">#</a> <code>mag</code></h3>
<p><code>mag</code> — extended stdlib builtin. Alias for <code>magnitude</code>.</p>
<pre><code class="lang-perl">my $result = mag $x
# or in a pipeline:
@list |> map mag |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-magenta">
<h3><a class="doc-anchor" href="#doc-magenta">#</a> <code>magenta</code></h3>
<p><code>magenta</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = magenta $x
# or in a pipeline:
@list |> map magenta |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-magenta-bold">
<h3><a class="doc-anchor" href="#doc-magenta-bold">#</a> <code>magenta_bold</code></h3>
<p><code>magenta_bold</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = magenta_bold $x
# or in a pipeline:
@list |> map magenta_bold |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-maglens">
<h3><a class="doc-anchor" href="#doc-maglens">#</a> <code>maglens</code></h3>
<p><code>maglens</code> — physics formulas builtin. Alias for <code>magnification_lens</code>.</p>
<pre><code class="lang-perl">my $result = maglens $x
# or in a pipeline:
@list |> map maglens |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-magnification-lens">
<h3><a class="doc-anchor" href="#doc-magnification-lens">#</a> <code>magnification_lens</code></h3>
<p><code>magnification_lens</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = magnification_lens $x
# or in a pipeline:
@list |> map magnification_lens |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-magnitude">
<h3><a class="doc-anchor" href="#doc-magnitude">#</a> <code>magnitude</code></h3>
<p><code>magnitude</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = magnitude $x
# or in a pipeline:
@list |> map magnitude |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mahal">
<h3><a class="doc-anchor" href="#doc-mahal">#</a> <code>mahal</code></h3>
<p><code>mahalanobis</code> — Mahalanobis distance. Args: data, center, inverse_covariance. Like R's mahalanobis().</p>
<pre><code class="lang-perl">my @d = @{mahal([[1,2],[3,4]], [2,3], [[1,0],[0,1]])}
</code></pre>
</article>
<article class="doc-entry" id="doc-majority">
<h3><a class="doc-anchor" href="#doc-majority">#</a> <code>majority</code></h3>
<p><code>majority</code> — extended stdlib batch 3 builtin. Alias for <code>majority_element</code>.</p>
<pre><code class="lang-perl">my $result = majority $x
# or in a pipeline:
@list |> map majority |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-majority-element">
<h3><a class="doc-anchor" href="#doc-majority-element">#</a> <code>majority_element</code></h3>
<p><code>majority_element</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = majority_element $x
# or in a pipeline:
@list |> map majority_element |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mall">
<h3><a class="doc-anchor" href="#doc-mall">#</a> <code>mall</code></h3>
<p><code>mall</code> — extended stdlib builtin. Alias for <code>match_all</code>.</p>
<pre><code class="lang-perl">my $result = mall $x
# or in a pipeline:
@list |> map mall |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mandel">
<h3><a class="doc-anchor" href="#doc-mandel">#</a> <code>mandel</code></h3>
<p><code>mandel</code> — algorithms / puzzles builtin. Alias for <code>mandelbrot_char</code>.</p>
<pre><code class="lang-perl">my $result = mandel $x
# or in a pipeline:
@list |> map mandel |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mandelbrot-char">
<h3><a class="doc-anchor" href="#doc-mandelbrot-char">#</a> <code>mandelbrot_char</code></h3>
<p><code>mandelbrot_char</code> — algorithms / puzzles builtin.</p>
<pre><code class="lang-perl">my $result = mandelbrot_char $x
# or in a pipeline:
@list |> map mandelbrot_char |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-manhattan-distance">
<h3><a class="doc-anchor" href="#doc-manhattan-distance">#</a> <code>manhattan_distance</code></h3>
<p><code>manhattan_distance</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = manhattan_distance $x
# or in a pipeline:
@list |> map manhattan_distance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mann-whitney">
<h3><a class="doc-anchor" href="#doc-mann-whitney">#</a> <code>mann_whitney</code></h3>
<p><code>wilcox_test</code> (aliases <code>wilcox</code>, <code>mann_whitney</code>) — Wilcoxon rank-sum test (Mann-Whitney U). Returns U statistic. Like R's wilcox.test().</p>
<pre><code class="lang-perl">my $U = wilcox([1,2,3], [4,5,6]) # 0 (no overlap)
</code></pre>
</article>
<article class="doc-entry" id="doc-map-chars">
<h3><a class="doc-anchor" href="#doc-map-chars">#</a> <code>map_chars</code></h3>
<p><code>map_chars</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = map_chars $x
# or in a pipeline:
@list |> map map_chars |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-map-indexed">
<h3><a class="doc-anchor" href="#doc-map-indexed">#</a> <code>map_indexed</code></h3>
<p><code>map_indexed</code> — go/general functional utilities builtin.</p>
<pre><code class="lang-perl">my $result = map_indexed $x
# or in a pipeline:
@list |> map map_indexed |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-map-keys-fn">
<h3><a class="doc-anchor" href="#doc-map-keys-fn">#</a> <code>map_keys_fn</code></h3>
<p><code>map_keys_fn</code> — hash ops (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = map_keys_fn $x
# or in a pipeline:
@list |> map map_keys_fn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-map-range">
<h3><a class="doc-anchor" href="#doc-map-range">#</a> <code>map_range</code></h3>
<p><code>map_range($value, $in_min, $in_max, $out_min, $out_max)</code> (alias <code>remap</code>) — remap a value from one range to another.</p>
<pre><code class="lang-perl">p remap(50, 0, 100, 0, 1) # 0.5
p remap(75, 0, 100, 0, 255) # 191.25 (percent to byte)
</code></pre>
</article>
<article class="doc-entry" id="doc-map-values-fn">
<h3><a class="doc-anchor" href="#doc-map-values-fn">#</a> <code>map_values_fn</code></h3>
<p><code>map_values_fn</code> — hash ops (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = map_values_fn $x
# or in a pipeline:
@list |> map map_values_fn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-map-while">
<h3><a class="doc-anchor" href="#doc-map-while">#</a> <code>map_while</code></h3>
<p><code>map_while</code> — rust iterator methods builtin.</p>
<pre><code class="lang-perl">my $result = map_while $x
# or in a pipeline:
@list |> map map_while |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mapcat">
<h3><a class="doc-anchor" href="#doc-mapcat">#</a> <code>mapcat</code></h3>
<p><code>mapcat</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = mapcat $x
# or in a pipeline:
@list |> map mapcat |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mapi">
<h3><a class="doc-anchor" href="#doc-mapi">#</a> <code>mapi</code></h3>
<p><code>mapi</code> — go/general functional utilities builtin. Alias for <code>map_indexed</code>.</p>
<pre><code class="lang-perl">my $result = mapi $x
# or in a pipeline:
@list |> map mapi |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mapw">
<h3><a class="doc-anchor" href="#doc-mapw">#</a> <code>mapw</code></h3>
<p><code>mapw</code> — rust iterator methods builtin. Alias for <code>map_while</code>.</p>
<pre><code class="lang-perl">my $result = mapw $x
# or in a pipeline:
@list |> map mapw |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-margin">
<h3><a class="doc-anchor" href="#doc-margin">#</a> <code>margin</code></h3>
<p><code>margin</code> — finance builtin.</p>
<pre><code class="lang-perl">my $result = margin $x
# or in a pipeline:
@list |> map margin |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-margin-price">
<h3><a class="doc-anchor" href="#doc-margin-price">#</a> <code>margin_price</code></h3>
<p><code>margin_price</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = margin_price $x
# or in a pipeline:
@list |> map margin_price |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-markup">
<h3><a class="doc-anchor" href="#doc-markup">#</a> <code>markup</code></h3>
<p><code>markup</code> — finance builtin.</p>
<pre><code class="lang-perl">my $result = markup $x
# or in a pipeline:
@list |> map markup |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-markup-price">
<h3><a class="doc-anchor" href="#doc-markup-price">#</a> <code>markup_price</code></h3>
<p><code>markup_price</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = markup_price $x
# or in a pipeline:
@list |> map markup_price |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mask">
<h3><a class="doc-anchor" href="#doc-mask">#</a> <code>mask</code></h3>
<p><code>mask</code> — string processing (uncategorized batch) builtin. Alias for <code>mask_string</code>.</p>
<pre><code class="lang-perl">my $result = mask $x
# or in a pipeline:
@list |> map mask |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mask-string">
<h3><a class="doc-anchor" href="#doc-mask-string">#</a> <code>mask_string</code></h3>
<p><code>mask_string</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = mask_string $x
# or in a pipeline:
@list |> map mask_string |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mat-mul">
<h3><a class="doc-anchor" href="#doc-mat-mul">#</a> <code>mat_mul</code></h3>
<p><code>mat_mul</code> — matrix / linear algebra builtin. Alias for <code>matrix_multiply</code>.</p>
<pre><code class="lang-perl">my $result = mat_mul $x
# or in a pipeline:
@list |> map mat_mul |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mat-scale">
<h3><a class="doc-anchor" href="#doc-mat-scale">#</a> <code>mat_scale</code></h3>
<p><code>mat_scale</code> — extended stdlib builtin. Alias for <code>matrix_scale</code>.</p>
<pre><code class="lang-perl">my $result = mat_scale $x
# or in a pipeline:
@list |> map mat_scale |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-match-all">
<h3><a class="doc-anchor" href="#doc-match-all">#</a> <code>match_all</code></h3>
<p><code>match_all</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = match_all $x
# or in a pipeline:
@list |> map match_all |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matches-regex">
<h3><a class="doc-anchor" href="#doc-matches-regex">#</a> <code>matches_regex</code></h3>
<p><code>matches_regex</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = matches_regex $x
# or in a pipeline:
@list |> map matches_regex |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matmul">
<h3><a class="doc-anchor" href="#doc-matmul">#</a> <code>matmul</code></h3>
<p><code>matmul</code> — extended stdlib builtin. Alias for <code>matrix_mul</code>.</p>
<pre><code class="lang-perl">my $result = matmul $x
# or in a pipeline:
@list |> map matmul |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-add">
<h3><a class="doc-anchor" href="#doc-matrix-add">#</a> <code>matrix_add</code></h3>
<p><code>matrix_add</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = matrix_add $x
# or in a pipeline:
@list |> map matrix_add |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-col">
<h3><a class="doc-anchor" href="#doc-matrix-col">#</a> <code>matrix_col</code></h3>
<p><code>matrix_col</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = matrix_col $x
# or in a pipeline:
@list |> map matrix_col |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-det">
<h3><a class="doc-anchor" href="#doc-matrix-det">#</a> <code>matrix_det</code></h3>
<p><code>matrix_det</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = matrix_det $x
# or in a pipeline:
@list |> map matrix_det |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-diag">
<h3><a class="doc-anchor" href="#doc-matrix-diag">#</a> <code>matrix_diag</code></h3>
<p><code>matrix_diag</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = matrix_diag $x
# or in a pipeline:
@list |> map matrix_diag |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-flatten">
<h3><a class="doc-anchor" href="#doc-matrix-flatten">#</a> <code>matrix_flatten</code></h3>
<p><code>matrix_flatten</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = matrix_flatten $x
# or in a pipeline:
@list |> map matrix_flatten |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-from-rows">
<h3><a class="doc-anchor" href="#doc-matrix-from-rows">#</a> <code>matrix_from_rows</code></h3>
<p><code>matrix_from_rows</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = matrix_from_rows $x
# or in a pipeline:
@list |> map matrix_from_rows |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-hadamard">
<h3><a class="doc-anchor" href="#doc-matrix-hadamard">#</a> <code>matrix_hadamard</code></h3>
<p><code>matrix_hadamard</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = matrix_hadamard $x
# or in a pipeline:
@list |> map matrix_hadamard |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-identity">
<h3><a class="doc-anchor" href="#doc-matrix-identity">#</a> <code>matrix_identity</code></h3>
<p><code>matrix_identity</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = matrix_identity $x
# or in a pipeline:
@list |> map matrix_identity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-inverse">
<h3><a class="doc-anchor" href="#doc-matrix-inverse">#</a> <code>matrix_inverse</code></h3>
<p><code>matrix_inverse</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = matrix_inverse $x
# or in a pipeline:
@list |> map matrix_inverse |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-lu">
<h3><a class="doc-anchor" href="#doc-matrix-lu">#</a> <code>matrix_lu</code></h3>
<p><code>matrix_lu</code> (alias <code>mlu</code>) computes the LU decomposition with partial pivoting. Returns [L, U, P] where PA = LU.</p>
<pre><code class="lang-perl">my ($L, $U, $P) = @{mlu([[4,3],[6,3]])}
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-map">
<h3><a class="doc-anchor" href="#doc-matrix-map">#</a> <code>matrix_map</code></h3>
<p><code>matrix_map</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = matrix_map $x
# or in a pipeline:
@list |> map matrix_map |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-max">
<h3><a class="doc-anchor" href="#doc-matrix-max">#</a> <code>matrix_max</code></h3>
<p><code>matrix_max</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = matrix_max $x
# or in a pipeline:
@list |> map matrix_max |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-min">
<h3><a class="doc-anchor" href="#doc-matrix-min">#</a> <code>matrix_min</code></h3>
<p><code>matrix_min</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = matrix_min $x
# or in a pipeline:
@list |> map matrix_min |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-mul">
<h3><a class="doc-anchor" href="#doc-matrix-mul">#</a> <code>matrix_mul</code></h3>
<p><code>matrix_mul</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = matrix_mul $x
# or in a pipeline:
@list |> map matrix_mul |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-mult">
<h3><a class="doc-anchor" href="#doc-matrix-mult">#</a> <code>matrix_mult</code></h3>
<p><code>matrix_mult</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = matrix_mult $x
# or in a pipeline:
@list |> map matrix_mult |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-multiply">
<h3><a class="doc-anchor" href="#doc-matrix-multiply">#</a> <code>matrix_multiply</code></h3>
<p><code>matrix_multiply</code> — matrix / linear algebra builtin.</p>
<pre><code class="lang-perl">my $result = matrix_multiply $x
# or in a pipeline:
@list |> map matrix_multiply |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-norm">
<h3><a class="doc-anchor" href="#doc-matrix-norm">#</a> <code>matrix_norm</code></h3>
<p><code>matrix_norm</code> (alias <code>mnorm</code>) computes a matrix norm. Default is Frobenius; pass 1 for max-column-sum, Inf for max-row-sum.</p>
<pre><code class="lang-perl">p mnorm([[3,4]]) # 5 (Frobenius)
p mnorm([[1,2],[3,4]], 1) # 6 (1-norm)
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-ones">
<h3><a class="doc-anchor" href="#doc-matrix-ones">#</a> <code>matrix_ones</code></h3>
<p><code>matrix_ones</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = matrix_ones $x
# or in a pipeline:
@list |> map matrix_ones |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-pinv">
<h3><a class="doc-anchor" href="#doc-matrix-pinv">#</a> <code>matrix_pinv</code></h3>
<p><code>matrix_pinv</code> (aliases <code>mpinv</code>, <code>pinv</code>) computes the Moore-Penrose pseudo-inverse via (A^T A)^{-1} A^T.</p>
<pre><code class="lang-perl">my $A_plus = pinv([[1,2],[3,4],[5,6]])
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-power">
<h3><a class="doc-anchor" href="#doc-matrix-power">#</a> <code>matrix_power</code></h3>
<p><code>matrix_power</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = matrix_power $x
# or in a pipeline:
@list |> map matrix_power |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-qr">
<h3><a class="doc-anchor" href="#doc-matrix-qr">#</a> <code>matrix_qr</code></h3>
<p><code>matrix_qr</code> (alias <code>mqr</code>) computes the QR decomposition via Gram-Schmidt orthogonalization. Returns [Q, R] where A = QR.</p>
<pre><code class="lang-perl">my ($Q, $R) = @{mqr([[1,1],[1,-1]])}
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-row">
<h3><a class="doc-anchor" href="#doc-matrix-row">#</a> <code>matrix_row</code></h3>
<p><code>matrix_row</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = matrix_row $x
# or in a pipeline:
@list |> map matrix_row |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-scalar">
<h3><a class="doc-anchor" href="#doc-matrix-scalar">#</a> <code>matrix_scalar</code></h3>
<p><code>matrix_scalar</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = matrix_scalar $x
# or in a pipeline:
@list |> map matrix_scalar |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-scale">
<h3><a class="doc-anchor" href="#doc-matrix-scale">#</a> <code>matrix_scale</code></h3>
<p><code>matrix_scale</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = matrix_scale $x
# or in a pipeline:
@list |> map matrix_scale |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-shape">
<h3><a class="doc-anchor" href="#doc-matrix-shape">#</a> <code>matrix_shape</code></h3>
<p><code>matrix_shape</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = matrix_shape $x
# or in a pipeline:
@list |> map matrix_shape |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-solve">
<h3><a class="doc-anchor" href="#doc-matrix-solve">#</a> <code>matrix_solve</code></h3>
<p><code>matrix_solve</code> (aliases <code>msolve</code>, <code>solve</code>) solves the linear system Ax=b via Gaussian elimination with partial pivoting. Returns the solution vector x.</p>
<pre><code class="lang-perl">my $A = [[2,1],[-1,1]]
my $b = [5,2]
my $x = solve($A, $b) # [1, 3]
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-sub">
<h3><a class="doc-anchor" href="#doc-matrix-sub">#</a> <code>matrix_sub</code></h3>
<p><code>matrix_sub</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = matrix_sub $x
# or in a pipeline:
@list |> map matrix_sub |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-sum">
<h3><a class="doc-anchor" href="#doc-matrix-sum">#</a> <code>matrix_sum</code></h3>
<p><code>matrix_sum</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = matrix_sum $x
# or in a pipeline:
@list |> map matrix_sum |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-trace">
<h3><a class="doc-anchor" href="#doc-matrix-trace">#</a> <code>matrix_trace</code></h3>
<p><code>matrix_trace</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = matrix_trace $x
# or in a pipeline:
@list |> map matrix_trace |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-transpose">
<h3><a class="doc-anchor" href="#doc-matrix-transpose">#</a> <code>matrix_transpose</code></h3>
<p><code>matrix_transpose</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = matrix_transpose $x
# or in a pipeline:
@list |> map matrix_transpose |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-matrix-zeros">
<h3><a class="doc-anchor" href="#doc-matrix-zeros">#</a> <code>matrix_zeros</code></h3>
<p><code>matrix_zeros</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = matrix_zeros $x
# or in a pipeline:
@list |> map matrix_zeros |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-max2">
<h3><a class="doc-anchor" href="#doc-max2">#</a> <code>max2</code></h3>
<p><code>max2</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = max2 $x
# or in a pipeline:
@list |> map max2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-max-abs">
<h3><a class="doc-anchor" href="#doc-max-abs">#</a> <code>max_abs</code></h3>
<p><code>max_abs</code> — trig / math (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = max_abs $x
# or in a pipeline:
@list |> map max_abs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-max-by">
<h3><a class="doc-anchor" href="#doc-max-by">#</a> <code>max_by</code></h3>
<p><code>max_by</code> — pipeline / string helpers builtin. Alias for <code>drop</code>.</p>
<pre><code class="lang-perl">my $result = max_by $x
# or in a pipeline:
@list |> map max_by |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-max-drawdown">
<h3><a class="doc-anchor" href="#doc-max-drawdown">#</a> <code>max_drawdown</code></h3>
<p><code>max_drawdown(@equity_curve)</code> (alias <code>mdd</code>) — computes the maximum peak-to-trough decline in a series of values. Returns as a decimal (0.2 = 20% drawdown). Key risk metric.</p>
<pre><code class="lang-perl">my @equity = (100, 120, 90, 110, 85, 130)
p mdd(@equity) # ~0.29 (29% max drawdown)
</code></pre>
</article>
<article class="doc-entry" id="doc-max-float">
<h3><a class="doc-anchor" href="#doc-max-float">#</a> <code>max_float</code></h3>
<p><code>max_float</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = max_float $x
# or in a pipeline:
@list |> map max_float |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-max-list">
<h3><a class="doc-anchor" href="#doc-max-list">#</a> <code>max_list</code></h3>
<p><code>max_list</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = max_list $x
# or in a pipeline:
@list |> map max_list |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-max-of">
<h3><a class="doc-anchor" href="#doc-max-of">#</a> <code>max_of</code></h3>
<p><code>max_of</code> — more list helpers builtin.</p>
<pre><code class="lang-perl">my $result = max_of $x
# or in a pipeline:
@list |> map max_of |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-max-sum-subarray">
<h3><a class="doc-anchor" href="#doc-max-sum-subarray">#</a> <code>max_sum_subarray</code></h3>
<p><code>max_sum_subarray</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = max_sum_subarray $x
# or in a pipeline:
@list |> map max_sum_subarray |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-maxby">
<h3><a class="doc-anchor" href="#doc-maxby">#</a> <code>maxby</code></h3>
<p><code>maxby</code> — additional missing stdlib functions builtin. Alias for <code>maximum_by</code>.</p>
<pre><code class="lang-perl">my $result = maxby $x
# or in a pipeline:
@list |> map maxby |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-maxdd">
<h3><a class="doc-anchor" href="#doc-maxdd">#</a> <code>maxdd</code></h3>
<p><code>maxdd</code> — finance (extended) builtin. Alias for <code>max_drawdown</code>.</p>
<pre><code class="lang-perl">my $result = maxdd $x
# or in a pipeline:
@list |> map maxdd |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-maximum-by">
<h3><a class="doc-anchor" href="#doc-maximum-by">#</a> <code>maximum_by</code></h3>
<p><code>maximum_by</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = maximum_by $x
# or in a pipeline:
@list |> map maximum_by |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-maxsub">
<h3><a class="doc-anchor" href="#doc-maxsub">#</a> <code>maxsub</code></h3>
<p><code>maxsub</code> — extended stdlib batch 3 builtin. Alias for <code>max_sum_subarray</code>.</p>
<pre><code class="lang-perl">my $result = maxsub $x
# or in a pipeline:
@list |> map maxsub |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mb-to-bytes">
<h3><a class="doc-anchor" href="#doc-mb-to-bytes">#</a> <code>mb_to_bytes</code></h3>
<p><code>mb_to_bytes</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = mb_to_bytes $input
</code></pre>
</article>
<article class="doc-entry" id="doc-mb-to-gb">
<h3><a class="doc-anchor" href="#doc-mb-to-gb">#</a> <code>mb_to_gb</code></h3>
<p><code>mb_to_gb</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = mb_to_gb $input
</code></pre>
</article>
<article class="doc-entry" id="doc-mcat">
<h3><a class="doc-anchor" href="#doc-mcat">#</a> <code>mcat</code></h3>
<p><code>mcat</code> — algebraic match builtin. Alias for <code>mapcat</code>.</p>
<pre><code class="lang-perl">my $result = mcat $x
# or in a pipeline:
@list |> map mcat |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mcol">
<h3><a class="doc-anchor" href="#doc-mcol">#</a> <code>mcol</code></h3>
<p><code>mcol</code> — extended stdlib builtin. Alias for <code>matrix_col</code>.</p>
<pre><code class="lang-perl">my $result = mcol $x
# or in a pipeline:
@list |> map mcol |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-md5">
<h3><a class="doc-anchor" href="#doc-md5">#</a> <code>md5</code></h3>
<p><code>md5</code> — crypto / encoding builtin.</p>
<pre><code class="lang-perl">my $result = md5 $x
# or in a pipeline:
@list |> map md5 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mdet">
<h3><a class="doc-anchor" href="#doc-mdet">#</a> <code>mdet</code></h3>
<p><code>mdet</code> — extended stdlib builtin. Alias for <code>matrix_det</code>.</p>
<pre><code class="lang-perl">my $result = mdet $x
# or in a pipeline:
@list |> map mdet |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mdiag">
<h3><a class="doc-anchor" href="#doc-mdiag">#</a> <code>mdiag</code></h3>
<p><code>mdiag</code> — extended stdlib builtin. Alias for <code>matrix_diag</code>.</p>
<pre><code class="lang-perl">my $result = mdiag $x
# or in a pipeline:
@list |> map mdiag |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mdist">
<h3><a class="doc-anchor" href="#doc-mdist">#</a> <code>mdist</code></h3>
<p><code>mdist</code> — extended stdlib builtin. Alias for <code>manhattan_distance</code>.</p>
<pre><code class="lang-perl">my $result = mdist $x
# or in a pipeline:
@list |> map mdist |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mean-absolute-error">
<h3><a class="doc-anchor" href="#doc-mean-absolute-error">#</a> <code>mean_absolute_error</code></h3>
<p><code>mean_absolute_error</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = mean_absolute_error $x
# or in a pipeline:
@list |> map mean_absolute_error |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mean-list">
<h3><a class="doc-anchor" href="#doc-mean-list">#</a> <code>mean_list</code></h3>
<p><code>mean_list</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = mean_list $x
# or in a pipeline:
@list |> map mean_list |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mean-squared-error">
<h3><a class="doc-anchor" href="#doc-mean-squared-error">#</a> <code>mean_squared_error</code></h3>
<p><code>mean_squared_error</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = mean_squared_error $x
# or in a pipeline:
@list |> map mean_squared_error |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-measure">
<h3><a class="doc-anchor" href="#doc-measure">#</a> <code>measure</code></h3>
<p><code>measure</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = measure $x
# or in a pipeline:
@list |> map measure |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-medfilt">
<h3><a class="doc-anchor" href="#doc-medfilt">#</a> <code>medfilt</code></h3>
<p><code>median_filter(\@signal, $window_size)</code> (alias <code>medfilt</code>) — applies a median filter for noise removal. Each output is the median of the surrounding window. Excellent for removing impulse noise while preserving edges.</p>
<pre><code class="lang-perl">my @spiky = (1, 2, 100, 3, 4) # 100 is spike
my $clean = medfilt(\@spiky, 3)
p @$clean # spike removed
</code></pre>
</article>
<article class="doc-entry" id="doc-median-absolute-deviation">
<h3><a class="doc-anchor" href="#doc-median-absolute-deviation">#</a> <code>median_absolute_deviation</code></h3>
<p><code>median_absolute_deviation</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = median_absolute_deviation $x
# or in a pipeline:
@list |> map median_absolute_deviation |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mem-free">
<h3><a class="doc-anchor" href="#doc-mem-free">#</a> <code>mem_free</code></h3>
<p><code>mem_free</code> — free/available physical RAM in bytes. On Linux reads <code>MemAvailable</code> from <code>/proc/meminfo</code> (falls back to <code>MemFree</code>). On macOS uses <code>vm.page_free_count</code> via sysctl. Returns <code>undef</code> on unsupported platforms.</p>
<pre><code class="lang-perl">p mem_free # 3821666304
p format_bytes(mem_free) # 3.6 GiB
my $pct = int(mem_free / mem_total * 100)
p "$pct% free"
</code></pre>
</article>
<article class="doc-entry" id="doc-mem-total">
<h3><a class="doc-anchor" href="#doc-mem-total">#</a> <code>mem_total</code></h3>
<p><code>mem_total</code> — total physical RAM in bytes. Uses <code>/proc/meminfo</code> on Linux, <code>sysctlbyname("hw.memsize")</code> on macOS. Returns <code>undef</code> on unsupported platforms.</p>
<pre><code class="lang-perl">p mem_total # 68719476736
p format_bytes(mem_total) # 64.0 GiB
</code></pre>
</article>
<article class="doc-entry" id="doc-mem-used">
<h3><a class="doc-anchor" href="#doc-mem-used">#</a> <code>mem_used</code></h3>
<p><code>mem_used</code> — used physical RAM in bytes (total - free). Returns <code>undef</code> if either <code>mem_total</code> or <code>mem_free</code> is unavailable.</p>
<pre><code class="lang-perl">p format_bytes(mem_used) # 60.4 GiB
gauge(mem_used / mem_total) |> p # memory usage gauge
</code></pre>
</article>
<article class="doc-entry" id="doc-merge-hash">
<h3><a class="doc-anchor" href="#doc-merge-hash">#</a> <code>merge_hash</code></h3>
<p><code>merge_hash</code> — hash helpers builtin.</p>
<pre><code class="lang-perl">my $result = merge_hash $x
# or in a pipeline:
@list |> map merge_hash |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-merge-sorted">
<h3><a class="doc-anchor" href="#doc-merge-sorted">#</a> <code>merge_sorted</code></h3>
<p><code>merge_sorted</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = merge_sorted $x
# or in a pipeline:
@list |> map merge_sorted |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-metaphone">
<h3><a class="doc-anchor" href="#doc-metaphone">#</a> <code>metaphone</code></h3>
<p><code>metaphone</code> — encoding / phonetics builtin.</p>
<pre><code class="lang-perl">my $result = metaphone $x
# or in a pipeline:
@list |> map metaphone |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-metph">
<h3><a class="doc-anchor" href="#doc-metph">#</a> <code>metph</code></h3>
<p><code>metph</code> — encoding / phonetics builtin. Alias for <code>metaphone</code>.</p>
<pre><code class="lang-perl">my $result = metph $x
# or in a pipeline:
@list |> map metph |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mflat">
<h3><a class="doc-anchor" href="#doc-mflat">#</a> <code>mflat</code></h3>
<p><code>mflat</code> — matrix operations (uncategorized batch) builtin. Alias for <code>matrix_flatten</code>.</p>
<pre><code class="lang-perl">my $result = mflat $x
# or in a pipeline:
@list |> map mflat |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mfromr">
<h3><a class="doc-anchor" href="#doc-mfromr">#</a> <code>mfromr</code></h3>
<p><code>mfromr</code> — matrix operations (uncategorized batch) builtin. Alias for <code>matrix_from_rows</code>.</p>
<pre><code class="lang-perl">my $result = mfromr $x
# or in a pipeline:
@list |> map mfromr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mhad">
<h3><a class="doc-anchor" href="#doc-mhad">#</a> <code>mhad</code></h3>
<p><code>mhad</code> — matrix operations (uncategorized batch) builtin. Alias for <code>matrix_hadamard</code>.</p>
<pre><code class="lang-perl">my $result = mhad $x
# or in a pipeline:
@list |> map mhad |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mid-str">
<h3><a class="doc-anchor" href="#doc-mid-str">#</a> <code>mid_str</code></h3>
<p><code>mid_str</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = mid_str $x
# or in a pipeline:
@list |> map mid_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mident">
<h3><a class="doc-anchor" href="#doc-mident">#</a> <code>mident</code></h3>
<p><code>mident</code> — extended stdlib builtin. Alias for <code>matrix_identity</code>.</p>
<pre><code class="lang-perl">my $result = mident $x
# or in a pipeline:
@list |> map mident |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-midpnt">
<h3><a class="doc-anchor" href="#doc-midpnt">#</a> <code>midpnt</code></h3>
<p><code>midpnt</code> — geometry / physics builtin. Alias for <code>midpoint</code>.</p>
<pre><code class="lang-perl">my $result = midpnt $x
# or in a pipeline:
@list |> map midpnt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-midpoint">
<h3><a class="doc-anchor" href="#doc-midpoint">#</a> <code>midpoint</code></h3>
<p><code>midpoint</code> — geometry / physics builtin.</p>
<pre><code class="lang-perl">my $result = midpoint $x
# or in a pipeline:
@list |> map midpoint |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-midpoint-of">
<h3><a class="doc-anchor" href="#doc-midpoint-of">#</a> <code>midpoint_of</code></h3>
<p><code>midpoint_of</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = midpoint_of $x
# or in a pipeline:
@list |> map midpoint_of |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-midpt">
<h3><a class="doc-anchor" href="#doc-midpt">#</a> <code>midpt</code></h3>
<p><code>midpt</code> — extended stdlib builtin. Alias for <code>midpoint_of</code>.</p>
<pre><code class="lang-perl">my $result = midpt $x
# or in a pipeline:
@list |> map midpt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-miles-to-km">
<h3><a class="doc-anchor" href="#doc-miles-to-km">#</a> <code>miles_to_km</code></h3>
<p><code>miles_to_km</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = miles_to_km $input
</code></pre>
</article>
<article class="doc-entry" id="doc-miles-to-m">
<h3><a class="doc-anchor" href="#doc-miles-to-m">#</a> <code>miles_to_m</code></h3>
<p><code>miles_to_m</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = miles_to_m $input
</code></pre>
</article>
<article class="doc-entry" id="doc-min2">
<h3><a class="doc-anchor" href="#doc-min2">#</a> <code>min2</code></h3>
<p><code>min2</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = min2 $x
# or in a pipeline:
@list |> map min2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-min-abs">
<h3><a class="doc-anchor" href="#doc-min-abs">#</a> <code>min_abs</code></h3>
<p><code>min_abs</code> — trig / math (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = min_abs $x
# or in a pipeline:
@list |> map min_abs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-min-by">
<h3><a class="doc-anchor" href="#doc-min-by">#</a> <code>min_by</code></h3>
<p><code>min_by</code> — pipeline / string helpers builtin. Alias for <code>drop</code>.</p>
<pre><code class="lang-perl">my $result = min_by $x
# or in a pipeline:
@list |> map min_by |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-min-float">
<h3><a class="doc-anchor" href="#doc-min-float">#</a> <code>min_float</code></h3>
<p><code>min_float</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = min_float $x
# or in a pipeline:
@list |> map min_float |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-min-list">
<h3><a class="doc-anchor" href="#doc-min-list">#</a> <code>min_list</code></h3>
<p><code>min_list</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = min_list $x
# or in a pipeline:
@list |> map min_list |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-min-max">
<h3><a class="doc-anchor" href="#doc-min-max">#</a> <code>min_max</code></h3>
<p><code>min_max</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = min_max $x
# or in a pipeline:
@list |> map min_max |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-min-of">
<h3><a class="doc-anchor" href="#doc-min-of">#</a> <code>min_of</code></h3>
<p><code>min_of</code> — more list helpers builtin.</p>
<pre><code class="lang-perl">my $result = min_of $x
# or in a pipeline:
@list |> map min_of |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-minby">
<h3><a class="doc-anchor" href="#doc-minby">#</a> <code>minby</code></h3>
<p><code>minby</code> — additional missing stdlib functions builtin. Alias for <code>minimum_by</code>.</p>
<pre><code class="lang-perl">my $result = minby $x
# or in a pipeline:
@list |> map minby |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-minimum-by">
<h3><a class="doc-anchor" href="#doc-minimum-by">#</a> <code>minimum_by</code></h3>
<p><code>minimum_by</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = minimum_by $x
# or in a pipeline:
@list |> map minimum_by |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-minkdist">
<h3><a class="doc-anchor" href="#doc-minkdist">#</a> <code>minkdist</code></h3>
<p><code>minkdist</code> — math / numeric (uncategorized batch) builtin. Alias for <code>minkowski_distance</code>.</p>
<pre><code class="lang-perl">my $result = minkdist $x
# or in a pipeline:
@list |> map minkdist |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-minkowski-distance">
<h3><a class="doc-anchor" href="#doc-minkowski-distance">#</a> <code>minkowski_distance</code></h3>
<p><code>minkowski_distance</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = minkowski_distance $x
# or in a pipeline:
@list |> map minkowski_distance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-minmax">
<h3><a class="doc-anchor" href="#doc-minmax">#</a> <code>minmax</code></h3>
<p><code>minmax</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = minmax $x
# or in a pipeline:
@list |> map minmax |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-minmax-by">
<h3><a class="doc-anchor" href="#doc-minmax-by">#</a> <code>minmax_by</code></h3>
<p><code>minmax_by</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = minmax_by $x
# or in a pipeline:
@list |> map minmax_by |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-minutes-to-hours">
<h3><a class="doc-anchor" href="#doc-minutes-to-hours">#</a> <code>minutes_to_hours</code></h3>
<p><code>minutes_to_hours</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = minutes_to_hours $input
</code></pre>
</article>
<article class="doc-entry" id="doc-minutes-to-seconds">
<h3><a class="doc-anchor" href="#doc-minutes-to-seconds">#</a> <code>minutes_to_seconds</code></h3>
<p><code>minutes_to_seconds</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = minutes_to_seconds $input
</code></pre>
</article>
<article class="doc-entry" id="doc-minv">
<h3><a class="doc-anchor" href="#doc-minv">#</a> <code>minv</code></h3>
<p><code>minv</code> — matrix operations (uncategorized batch) builtin. Alias for <code>matrix_inverse</code>.</p>
<pre><code class="lang-perl">my $result = minv $x
# or in a pipeline:
@list |> map minv |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mirror-string">
<h3><a class="doc-anchor" href="#doc-mirror-string">#</a> <code>mirror_string</code></h3>
<p><code>mirror_string</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = mirror_string $x
# or in a pipeline:
@list |> map mirror_string |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mish">
<h3><a class="doc-anchor" href="#doc-mish">#</a> <code>mish</code></h3>
<p><code>mish</code> applies the Mish activation: x·tanh(softplus(x)). Often outperforms ReLU/Swish.</p>
<pre><code class="lang-perl">p mish(1) # 0.8651
p mish(-1) # -0.3034
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-to-cups">
<h3><a class="doc-anchor" href="#doc-ml-to-cups">#</a> <code>ml_to_cups</code></h3>
<p><code>ml_to_cups</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = ml_to_cups $input
</code></pre>
</article>
<article class="doc-entry" id="doc-ml-to-liters">
<h3><a class="doc-anchor" href="#doc-ml-to-liters">#</a> <code>ml_to_liters</code></h3>
<p><code>ml_to_liters</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = ml_to_liters $input
</code></pre>
</article>
<article class="doc-entry" id="doc-mm">
<h3><a class="doc-anchor" href="#doc-mm">#</a> <code>mm</code></h3>
<p><code>mm</code> — extended stdlib builtin. Alias for <code>matrix_mul</code>.</p>
<pre><code class="lang-perl">my $result = mm $x
# or in a pipeline:
@list |> map mm |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mmap">
<h3><a class="doc-anchor" href="#doc-mmap">#</a> <code>mmap</code></h3>
<p><code>mmap</code> — matrix operations (uncategorized batch) builtin. Alias for <code>matrix_map</code>.</p>
<pre><code class="lang-perl">my $result = mmap $x
# or in a pipeline:
@list |> map mmap |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mmax">
<h3><a class="doc-anchor" href="#doc-mmax">#</a> <code>mmax</code></h3>
<p><code>mmax</code> — matrix operations (uncategorized batch) builtin. Alias for <code>matrix_max</code>.</p>
<pre><code class="lang-perl">my $result = mmax $x
# or in a pipeline:
@list |> map mmax |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mmin">
<h3><a class="doc-anchor" href="#doc-mmin">#</a> <code>mmin</code></h3>
<p><code>mmin</code> — matrix operations (uncategorized batch) builtin. Alias for <code>matrix_min</code>.</p>
<pre><code class="lang-perl">my $result = mmin $x
# or in a pipeline:
@list |> map mmin |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mmult">
<h3><a class="doc-anchor" href="#doc-mmult">#</a> <code>mmult</code></h3>
<p><code>mmult</code> — extended stdlib builtin. Alias for <code>matrix_mult</code>.</p>
<pre><code class="lang-perl">my $result = mmult $x
# or in a pipeline:
@list |> map mmult |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mmx">
<h3><a class="doc-anchor" href="#doc-mmx">#</a> <code>mmx</code></h3>
<p><code>mmx</code> — python/ruby stdlib builtin. Alias for <code>minmax</code>.</p>
<pre><code class="lang-perl">my $result = mmx $x
# or in a pipeline:
@list |> map mmx |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mmxb">
<h3><a class="doc-anchor" href="#doc-mmxb">#</a> <code>mmxb</code></h3>
<p><code>mmxb</code> — python/ruby stdlib builtin. Alias for <code>minmax_by</code>.</p>
<pre><code class="lang-perl">my $result = mmxb $x
# or in a pipeline:
@list |> map mmxb |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mob">
<h3><a class="doc-anchor" href="#doc-mob">#</a> <code>mob</code></h3>
<p><code>mob</code> — extended stdlib batch 3 builtin. Alias for <code>mobius</code>.</p>
<pre><code class="lang-perl">my $result = mob $x
# or in a pipeline:
@list |> map mob |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mobius">
<h3><a class="doc-anchor" href="#doc-mobius">#</a> <code>mobius</code></h3>
<p><code>mobius</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = mobius $x
# or in a pipeline:
@list |> map mobius |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mod-exp">
<h3><a class="doc-anchor" href="#doc-mod-exp">#</a> <code>mod_exp</code></h3>
<p><code>mod_exp</code> (aliases <code>modexp</code>, <code>powmod</code>) computes modular exponentiation: base^exp mod m, using fast binary exponentiation.</p>
<pre><code class="lang-perl">p powmod(2, 10, 1000) # 24 (2^10 mod 1000)
p powmod(3, 13, 50) # 7
</code></pre>
</article>
<article class="doc-entry" id="doc-mod-inv">
<h3><a class="doc-anchor" href="#doc-mod-inv">#</a> <code>mod_inv</code></h3>
<p><code>mod_inv</code> (alias <code>modinv</code>) computes the modular multiplicative inverse via extended Euclidean algorithm. Errors if no inverse exists.</p>
<pre><code class="lang-perl">p modinv(3, 7) # 5 (3*5 ≡ 1 mod 7)
</code></pre>
</article>
<article class="doc-entry" id="doc-mod-op">
<h3><a class="doc-anchor" href="#doc-mod-op">#</a> <code>mod_op</code></h3>
<p><code>mod_op</code> — trig / math (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = mod_op $x
# or in a pipeline:
@list |> map mod_op |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-moddur">
<h3><a class="doc-anchor" href="#doc-moddur">#</a> <code>moddur</code></h3>
<p><code>moddur</code> — finance (extended) builtin. Alias for <code>modified_duration</code>.</p>
<pre><code class="lang-perl">my $result = moddur $x
# or in a pipeline:
@list |> map moddur |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mode-list">
<h3><a class="doc-anchor" href="#doc-mode-list">#</a> <code>mode_list</code></h3>
<p><code>mode_list</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = mode_list $x
# or in a pipeline:
@list |> map mode_list |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mode-stat">
<h3><a class="doc-anchor" href="#doc-mode-stat">#</a> <code>mode_stat</code></h3>
<p><code>mode_stat</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = mode_stat $x
# or in a pipeline:
@list |> map mode_stat |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mode-val">
<h3><a class="doc-anchor" href="#doc-mode-val">#</a> <code>mode_val</code></h3>
<p><code>mode_val</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = mode_val $x
# or in a pipeline:
@list |> map mode_val |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-modified-duration">
<h3><a class="doc-anchor" href="#doc-modified-duration">#</a> <code>modified_duration</code></h3>
<p><code>modified_duration($face, $coupon_rate, $ytm, $periods)</code> (alias <code>mod_dur</code>) — computes modified duration, which directly measures price sensitivity to yield changes. Equal to Macaulay duration / (1 + ytm).</p>
<pre><code class="lang-perl">p mod_dur(1000, 0.05, 0.05, 10) # ~7.3
</code></pre>
</article>
<article class="doc-entry" id="doc-momentum">
<h3><a class="doc-anchor" href="#doc-momentum">#</a> <code>momentum</code></h3>
<p><code>momentum($mass, $velocity)</code> — compute momentum p = mv (kg⋅m/s).</p>
<pre><code class="lang-perl">p momentum(10, 5) # 50 kg⋅m/s
</code></pre>
</article>
<article class="doc-entry" id="doc-mones">
<h3><a class="doc-anchor" href="#doc-mones">#</a> <code>mones</code></h3>
<p><code>mones</code> — extended stdlib builtin. Alias for <code>matrix_ones</code>.</p>
<pre><code class="lang-perl">my $result = mones $x
# or in a pipeline:
@list |> map mones |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-month-name">
<h3><a class="doc-anchor" href="#doc-month-name">#</a> <code>month_name</code></h3>
<p><code>month_name</code> — date helpers builtin.</p>
<pre><code class="lang-perl">my $result = month_name $x
# or in a pipeline:
@list |> map month_name |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-month-short">
<h3><a class="doc-anchor" href="#doc-month-short">#</a> <code>month_short</code></h3>
<p><code>month_short</code> — date helpers builtin.</p>
<pre><code class="lang-perl">my $result = month_short $x
# or in a pipeline:
@list |> map month_short |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-morse">
<h3><a class="doc-anchor" href="#doc-morse">#</a> <code>morse</code></h3>
<p><code>morse</code> — encoding / phonetics builtin. Alias for <code>morse_encode</code>.</p>
<pre><code class="lang-perl">my $result = morse $x
# or in a pipeline:
@list |> map morse |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-morse-decode">
<h3><a class="doc-anchor" href="#doc-morse-decode">#</a> <code>morse_decode</code></h3>
<p><code>morse_decode</code> — encoding / phonetics builtin.</p>
<pre><code class="lang-perl">my $result = morse_decode $x
# or in a pipeline:
@list |> map morse_decode |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-morse-encode">
<h3><a class="doc-anchor" href="#doc-morse-encode">#</a> <code>morse_encode</code></h3>
<p><code>morse_encode</code> — encoding / phonetics builtin.</p>
<pre><code class="lang-perl">my $result = morse_encode $x
# or in a pipeline:
@list |> map morse_encode |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mortgage-payment">
<h3><a class="doc-anchor" href="#doc-mortgage-payment">#</a> <code>mortgage_payment</code></h3>
<p><code>mortgage_payment</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = mortgage_payment $x
# or in a pipeline:
@list |> map mortgage_payment |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-most-common">
<h3><a class="doc-anchor" href="#doc-most-common">#</a> <code>most_common</code></h3>
<p><code>most_common</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = most_common $x
# or in a pipeline:
@list |> map most_common |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-movavg">
<h3><a class="doc-anchor" href="#doc-movavg">#</a> <code>movavg</code></h3>
<p><code>movavg</code> — math / numeric (uncategorized batch) builtin. Alias for <code>moving_average</code>.</p>
<pre><code class="lang-perl">my $result = movavg $x
# or in a pipeline:
@list |> map movavg |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-moving-average">
<h3><a class="doc-anchor" href="#doc-moving-average">#</a> <code>moving_average</code></h3>
<p><code>moving_average</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = moving_average $x
# or in a pipeline:
@list |> map moving_average |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mplanck">
<h3><a class="doc-anchor" href="#doc-mplanck">#</a> <code>mplanck</code></h3>
<p><code>mplanck</code> — physics constants builtin. Alias for <code>planck_mass</code>.</p>
<pre><code class="lang-perl">my $result = mplanck $x
# or in a pipeline:
@list |> map mplanck |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mpow">
<h3><a class="doc-anchor" href="#doc-mpow">#</a> <code>mpow</code></h3>
<p><code>mpow</code> — matrix operations (uncategorized batch) builtin. Alias for <code>matrix_power</code>.</p>
<pre><code class="lang-perl">my $result = mpow $x
# or in a pipeline:
@list |> map mpow |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mrow">
<h3><a class="doc-anchor" href="#doc-mrow">#</a> <code>mrow</code></h3>
<p><code>mrow</code> — extended stdlib builtin. Alias for <code>matrix_row</code>.</p>
<pre><code class="lang-perl">my $result = mrow $x
# or in a pipeline:
@list |> map mrow |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ms-to-ns">
<h3><a class="doc-anchor" href="#doc-ms-to-ns">#</a> <code>ms_to_ns</code></h3>
<p><code>ms_to_ns</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = ms_to_ns $input
</code></pre>
</article>
<article class="doc-entry" id="doc-ms-to-s">
<h3><a class="doc-anchor" href="#doc-ms-to-s">#</a> <code>ms_to_s</code></h3>
<p><code>ms_to_s</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = ms_to_s $input
</code></pre>
</article>
<article class="doc-entry" id="doc-mscal">
<h3><a class="doc-anchor" href="#doc-mscal">#</a> <code>mscal</code></h3>
<p><code>mscal</code> — extended stdlib builtin. Alias for <code>matrix_scalar</code>.</p>
<pre><code class="lang-perl">my $result = mscal $x
# or in a pipeline:
@list |> map mscal |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mse">
<h3><a class="doc-anchor" href="#doc-mse">#</a> <code>mse</code></h3>
<p><code>mse</code> — math functions builtin.</p>
<pre><code class="lang-perl">my $result = mse $x
# or in a pipeline:
@list |> map mse |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-msgctl">
<h3><a class="doc-anchor" href="#doc-msgctl">#</a> <code>msgctl</code></h3>
<p><code>msgctl</code> — sysv ipc builtin.</p>
<pre><code class="lang-perl">my $result = msgctl $x
# or in a pipeline:
@list |> map msgctl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-msgget">
<h3><a class="doc-anchor" href="#doc-msgget">#</a> <code>msgget</code></h3>
<p><code>msgget</code> — sysv ipc builtin.</p>
<pre><code class="lang-perl">my $result = msgget $x
# or in a pipeline:
@list |> map msgget |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-msgrcv">
<h3><a class="doc-anchor" href="#doc-msgrcv">#</a> <code>msgrcv</code></h3>
<p><code>msgrcv</code> — sysv ipc builtin.</p>
<pre><code class="lang-perl">my $result = msgrcv $x
# or in a pipeline:
@list |> map msgrcv |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-msgsnd">
<h3><a class="doc-anchor" href="#doc-msgsnd">#</a> <code>msgsnd</code></h3>
<p><code>msgsnd</code> — sysv ipc builtin.</p>
<pre><code class="lang-perl">my $result = msgsnd $x
# or in a pipeline:
@list |> map msgsnd |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mshape">
<h3><a class="doc-anchor" href="#doc-mshape">#</a> <code>mshape</code></h3>
<p><code>mshape</code> — extended stdlib builtin. Alias for <code>matrix_shape</code>.</p>
<pre><code class="lang-perl">my $result = mshape $x
# or in a pipeline:
@list |> map mshape |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-msorted">
<h3><a class="doc-anchor" href="#doc-msorted">#</a> <code>msorted</code></h3>
<p><code>msorted</code> — matrix operations (uncategorized batch) builtin. Alias for <code>merge_sorted</code>.</p>
<pre><code class="lang-perl">my $result = msorted $x
# or in a pipeline:
@list |> map msorted |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mst">
<h3><a class="doc-anchor" href="#doc-mst">#</a> <code>mst</code></h3>
<p><code>prim_mst</code> (aliases <code>mst</code>, <code>prim</code>) computes the minimum spanning tree weight via Prim's algorithm. Takes an adjacency matrix.</p>
<pre><code class="lang-perl">p mst([[0,2,0],[2,0,3],[0,3,0]]) # 5
</code></pre>
</article>
<article class="doc-entry" id="doc-mstat">
<h3><a class="doc-anchor" href="#doc-mstat">#</a> <code>mstat</code></h3>
<p><code>mstat</code> — extended stdlib builtin. Alias for <code>mode_stat</code>.</p>
<pre><code class="lang-perl">my $result = mstat $x
# or in a pipeline:
@list |> map mstat |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-msub">
<h3><a class="doc-anchor" href="#doc-msub">#</a> <code>msub</code></h3>
<p><code>msub</code> — extended stdlib builtin. Alias for <code>matrix_sub</code>.</p>
<pre><code class="lang-perl">my $result = msub $x
# or in a pipeline:
@list |> map msub |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-msum">
<h3><a class="doc-anchor" href="#doc-msum">#</a> <code>msum</code></h3>
<p><code>msum</code> — matrix operations (uncategorized batch) builtin. Alias for <code>matrix_sum</code>.</p>
<pre><code class="lang-perl">my $result = msum $x
# or in a pipeline:
@list |> map msum |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-msun">
<h3><a class="doc-anchor" href="#doc-msun">#</a> <code>msun</code></h3>
<p><code>sun_mass</code> (alias <code>msun</code>) — M☉ ≈ 1.989×10³⁰ kg. Mass of Sun (solar mass).</p>
<pre><code class="lang-perl">p msun # 1.98892e30 kg
</code></pre>
</article>
<article class="doc-entry" id="doc-mtime">
<h3><a class="doc-anchor" href="#doc-mtime">#</a> <code>mtime</code></h3>
<p><code>mtime</code> — file stat / path builtin. Alias for <code>file_mtime</code>.</p>
<pre><code class="lang-perl">my $result = mtime $x
# or in a pipeline:
@list |> map mtime |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mtrace">
<h3><a class="doc-anchor" href="#doc-mtrace">#</a> <code>mtrace</code></h3>
<p><code>mtrace</code> — extended stdlib builtin. Alias for <code>matrix_trace</code>.</p>
<pre><code class="lang-perl">my $result = mtrace $x
# or in a pipeline:
@list |> map mtrace |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mtrans">
<h3><a class="doc-anchor" href="#doc-mtrans">#</a> <code>mtrans</code></h3>
<p><code>mtrans</code> — matrix operations (uncategorized batch) builtin. Alias for <code>matrix_transpose</code>.</p>
<pre><code class="lang-perl">my $result = mtrans $x
# or in a pipeline:
@list |> map mtrans |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mu0">
<h3><a class="doc-anchor" href="#doc-mu0">#</a> <code>mu0</code></h3>
<p><code>mu0</code> — physics constants builtin. Alias for <code>vacuum_permeability</code>.</p>
<pre><code class="lang-perl">my $result = mu0 $x
# or in a pipeline:
@list |> map mu0 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mub">
<h3><a class="doc-anchor" href="#doc-mub">#</a> <code>mub</code></h3>
<p><code>mub</code> — physics constants builtin. Alias for <code>bohr_magneton</code>.</p>
<pre><code class="lang-perl">my $result = mub $x
# or in a pipeline:
@list |> map mub |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-multinom">
<h3><a class="doc-anchor" href="#doc-multinom">#</a> <code>multinom</code></h3>
<p><code>multinom</code> — math / numeric (uncategorized batch) builtin. Alias for <code>multinomial</code>.</p>
<pre><code class="lang-perl">my $result = multinom $x
# or in a pipeline:
@list |> map multinom |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-multinomial">
<h3><a class="doc-anchor" href="#doc-multinomial">#</a> <code>multinomial</code></h3>
<p><code>multinomial</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = multinomial $x
# or in a pipeline:
@list |> map multinomial |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mun">
<h3><a class="doc-anchor" href="#doc-mun">#</a> <code>mun</code></h3>
<p><code>mun</code> — physics constants builtin. Alias for <code>nuclear_magneton</code>.</p>
<pre><code class="lang-perl">my $result = mun $x
# or in a pipeline:
@list |> map mun |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-mzeros">
<h3><a class="doc-anchor" href="#doc-mzeros">#</a> <code>mzeros</code></h3>
<p><code>mzeros</code> — extended stdlib builtin. Alias for <code>matrix_zeros</code>.</p>
<pre><code class="lang-perl">my $result = mzeros $x
# or in a pipeline:
@list |> map mzeros |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nanoid">
<h3><a class="doc-anchor" href="#doc-nanoid">#</a> <code>nanoid</code></h3>
<p><code>nanoid</code> — id helpers builtin.</p>
<pre><code class="lang-perl">my $result = nanoid $x
# or in a pipeline:
@list |> map nanoid |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nato">
<h3><a class="doc-anchor" href="#doc-nato">#</a> <code>nato</code></h3>
<p><code>nato</code> — encoding / phonetics builtin. Alias for <code>nato_phonetic</code>.</p>
<pre><code class="lang-perl">my $result = nato $x
# or in a pipeline:
@list |> map nato |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nato-phonetic">
<h3><a class="doc-anchor" href="#doc-nato-phonetic">#</a> <code>nato_phonetic</code></h3>
<p><code>nato_phonetic</code> — encoding / phonetics builtin.</p>
<pre><code class="lang-perl">my $result = nato_phonetic $input
</code></pre>
</article>
<article class="doc-entry" id="doc-ncol">
<h3><a class="doc-anchor" href="#doc-ncol">#</a> <code>ncol</code></h3>
<p><code>ncol</code> — number of columns in a matrix.</p>
<pre><code class="lang-perl">p ncol([[1,2,3],[4,5,6]]) # 3
</code></pre>
</article>
<article class="doc-entry" id="doc-ndivs">
<h3><a class="doc-anchor" href="#doc-ndivs">#</a> <code>ndivs</code></h3>
<p><code>ndivs</code> — math / numeric (uncategorized batch) builtin. Alias for <code>num_divisors</code>.</p>
<pre><code class="lang-perl">my $result = ndivs $x
# or in a pipeline:
@list |> map ndivs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-neg-inf">
<h3><a class="doc-anchor" href="#doc-neg-inf">#</a> <code>neg_inf</code></h3>
<p><code>neg_inf</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = neg_inf $x
# or in a pipeline:
@list |> map neg_inf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-neg-n">
<h3><a class="doc-anchor" href="#doc-neg-n">#</a> <code>neg_n</code></h3>
<p><code>neg_n</code> — trivial numeric / predicate builtins builtin. Alias for <code>negative</code>.</p>
<pre><code class="lang-perl">my $result = neg_n $x
# or in a pipeline:
@list |> map neg_n |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-negate">
<h3><a class="doc-anchor" href="#doc-negate">#</a> <code>negate</code></h3>
<p><code>negate</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = negate $x
# or in a pipeline:
@list |> map negate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-negate-each">
<h3><a class="doc-anchor" href="#doc-negate-each">#</a> <code>negate_each</code></h3>
<p><code>negate_each</code> — trivial numeric helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = negate_each $x
# or in a pipeline:
@list |> map negate_each |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-negative">
<h3><a class="doc-anchor" href="#doc-negative">#</a> <code>negative</code></h3>
<p><code>negative</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = negative $x
# or in a pipeline:
@list |> map negative |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-neither">
<h3><a class="doc-anchor" href="#doc-neither">#</a> <code>neither</code></h3>
<p><code>neither</code> — boolean combinators builtin.</p>
<pre><code class="lang-perl">my $result = neither $x
# or in a pipeline:
@list |> map neither |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-neutron-mass">
<h3><a class="doc-anchor" href="#doc-neutron-mass">#</a> <code>neutron_mass</code></h3>
<p><code>neutron_mass</code> — physics constants builtin.</p>
<pre><code class="lang-perl">my $result = neutron_mass $x
# or in a pipeline:
@list |> map neutron_mass |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-newton">
<h3><a class="doc-anchor" href="#doc-newton">#</a> <code>newton</code></h3>
<p><code>newton_method</code> (aliases <code>newton</code>, <code>newton_raphson</code>) finds a root via Newton-Raphson. Takes f, f', x0, and optional tolerance.</p>
<pre><code class="lang-perl">my $root = newton(fn { $_[0]**2 - 2 }, fn { 2*$_[0] }, 1.5) # √2
</code></pre>
</article>
<article class="doc-entry" id="doc-newtons-to-lbf">
<h3><a class="doc-anchor" href="#doc-newtons-to-lbf">#</a> <code>newtons_to_lbf</code></h3>
<p><code>newtons_to_lbf</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = newtons_to_lbf $input
</code></pre>
</article>
<article class="doc-entry" id="doc-next-permutation">
<h3><a class="doc-anchor" href="#doc-next-permutation">#</a> <code>next_permutation</code></h3>
<p><code>next_permutation</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = next_permutation $x
# or in a pipeline:
@list |> map next_permutation |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-next-prime">
<h3><a class="doc-anchor" href="#doc-next-prime">#</a> <code>next_prime</code></h3>
<p><code>next_prime</code> — number theory / primes builtin.</p>
<pre><code class="lang-perl">my $result = next_prime $x
# or in a pipeline:
@list |> map next_prime |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nfirst">
<h3><a class="doc-anchor" href="#doc-nfirst">#</a> <code>nfirst</code></h3>
<p><code>nfirst</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = nfirst $x
# or in a pipeline:
@list |> map nfirst |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nfs">
<h3><a class="doc-anchor" href="#doc-nfs">#</a> <code>nfs</code></h3>
<p><code>nfs</code> — algebraic match builtin. Alias for <code>nfirst</code>.</p>
<pre><code class="lang-perl">my $result = nfs $x
# or in a pipeline:
@list |> map nfs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ngram">
<h3><a class="doc-anchor" href="#doc-ngram">#</a> <code>ngram</code></h3>
<p><code>ngram</code> — string processing (uncategorized batch) builtin. Alias for <code>ngrams</code>.</p>
<pre><code class="lang-perl">my $result = ngram $x
# or in a pipeline:
@list |> map ngram |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ngrams">
<h3><a class="doc-anchor" href="#doc-ngrams">#</a> <code>ngrams</code></h3>
<p><code>ngrams</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = ngrams $x
# or in a pipeline:
@list |> map ngrams |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nmass">
<h3><a class="doc-anchor" href="#doc-nmass">#</a> <code>nmass</code></h3>
<p><code>nmass</code> — physics constants builtin. Alias for <code>neutron_mass</code>.</p>
<pre><code class="lang-perl">my $result = nmass $x
# or in a pipeline:
@list |> map nmass |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nne">
<h3><a class="doc-anchor" href="#doc-nne">#</a> <code>nne</code></h3>
<p><code>nne</code> — algebraic match builtin. Alias for <code>nnext</code>.</p>
<pre><code class="lang-perl">my $result = nne $x
# or in a pipeline:
@list |> map nne |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nnext">
<h3><a class="doc-anchor" href="#doc-nnext">#</a> <code>nnext</code></h3>
<p><code>nnext</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = nnext $x
# or in a pipeline:
@list |> map nnext |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nohtml">
<h3><a class="doc-anchor" href="#doc-nohtml">#</a> <code>nohtml</code></h3>
<p><code>nohtml</code> — string processing (uncategorized batch) builtin. Alias for <code>strip_html</code>.</p>
<pre><code class="lang-perl">my $result = nohtml $x
# or in a pipeline:
@list |> map nohtml |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-none-match">
<h3><a class="doc-anchor" href="#doc-none-match">#</a> <code>none_match</code></h3>
<p><code>none_match</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = none_match $x
# or in a pipeline:
@list |> map none_match |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nonem">
<h3><a class="doc-anchor" href="#doc-nonem">#</a> <code>nonem</code></h3>
<p><code>nonem</code> — python/ruby stdlib builtin. Alias for <code>none_match</code>.</p>
<pre><code class="lang-perl">my $result = nonem $x
# or in a pipeline:
@list |> map nonem |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nonempty-count">
<h3><a class="doc-anchor" href="#doc-nonempty-count">#</a> <code>nonempty_count</code></h3>
<p><code>nonempty_count</code> — counters (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = nonempty_count $x
# or in a pipeline:
@list |> map nonempty_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nonzero">
<h3><a class="doc-anchor" href="#doc-nonzero">#</a> <code>nonzero</code></h3>
<p><code>nonzero</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = nonzero $x
# or in a pipeline:
@list |> map nonzero |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-noop-val">
<h3><a class="doc-anchor" href="#doc-noop-val">#</a> <code>noop_val</code></h3>
<p><code>noop_val</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = noop_val $x
# or in a pipeline:
@list |> map noop_val |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nop">
<h3><a class="doc-anchor" href="#doc-nop">#</a> <code>nop</code></h3>
<p><code>nop</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = nop $x
# or in a pipeline:
@list |> map nop |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-normal-cdf">
<h3><a class="doc-anchor" href="#doc-normal-cdf">#</a> <code>normal_cdf</code></h3>
<p><code>normal_cdf($x, $mu, $sigma)</code> (alias <code>normcdf</code>) — cumulative distribution function. Returns probability that a value is ≤ x.</p>
<pre><code class="lang-perl">p normcdf(0) # 0.5 (half below mean)
p normcdf(1.96) # ~0.975 (95% confidence bound)
</code></pre>
</article>
<article class="doc-entry" id="doc-normal-pdf">
<h3><a class="doc-anchor" href="#doc-normal-pdf">#</a> <code>normal_pdf</code></h3>
<p><code>normal_pdf($x, $mu, $sigma)</code> (alias <code>normpdf</code>) — normal/Gaussian distribution probability density function. Default: μ=0, σ=1 (standard normal).</p>
<pre><code class="lang-perl">p normpdf(0) # ~0.399 (peak of standard normal)
p normpdf(0, 100, 15) # PDF at IQ=100, mean=100, stddev=15
</code></pre>
</article>
<article class="doc-entry" id="doc-normalize-array">
<h3><a class="doc-anchor" href="#doc-normalize-array">#</a> <code>normalize_array</code></h3>
<p><code>normalize_array</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = normalize_array $x
# or in a pipeline:
@list |> map normalize_array |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-normalize-list">
<h3><a class="doc-anchor" href="#doc-normalize-list">#</a> <code>normalize_list</code></h3>
<p><code>normalize_list</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = normalize_list $x
# or in a pipeline:
@list |> map normalize_list |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-normalize-range">
<h3><a class="doc-anchor" href="#doc-normalize-range">#</a> <code>normalize_range</code></h3>
<p><code>normalize_range</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = normalize_range $x
# or in a pipeline:
@list |> map normalize_range |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-normalize-signal">
<h3><a class="doc-anchor" href="#doc-normalize-signal">#</a> <code>normalize_signal</code></h3>
<p><code>normalize_signal(\@signal)</code> (alias <code>normsig</code>) — scales signal to range [-1, 1] based on its peak absolute value. Useful for audio processing.</p>
<pre><code class="lang-perl">my $norm = normsig(\@audio)
p max(map { abs } @$norm) # 1
</code></pre>
</article>
<article class="doc-entry" id="doc-normalize-spaces">
<h3><a class="doc-anchor" href="#doc-normalize-spaces">#</a> <code>normalize_spaces</code></h3>
<p><code>normalize_spaces</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = normalize_spaces $x
# or in a pipeline:
@list |> map normalize_spaces |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-normalize-vec">
<h3><a class="doc-anchor" href="#doc-normalize-vec">#</a> <code>normalize_vec</code></h3>
<p><code>normalize_vec</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = normalize_vec $x
# or in a pipeline:
@list |> map normalize_vec |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-normalize-whitespace">
<h3><a class="doc-anchor" href="#doc-normalize-whitespace">#</a> <code>normalize_whitespace</code></h3>
<p><code>normalize_whitespace</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = normalize_whitespace $x
# or in a pipeline:
@list |> map normalize_whitespace |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-normarr">
<h3><a class="doc-anchor" href="#doc-normarr">#</a> <code>normarr</code></h3>
<p><code>normarr</code> — matrix operations (uncategorized batch) builtin. Alias for <code>normalize_array</code>.</p>
<pre><code class="lang-perl">my $result = normarr $x
# or in a pipeline:
@list |> map normarr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-not-any">
<h3><a class="doc-anchor" href="#doc-not-any">#</a> <code>not_any</code></h3>
<p><code>not_any</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = not_any $x
# or in a pipeline:
@list |> map not_any |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-not-each">
<h3><a class="doc-anchor" href="#doc-not-each">#</a> <code>not_each</code></h3>
<p><code>not_each</code> — trivial numeric helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = not_each $x
# or in a pipeline:
@list |> map not_each |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-not-elem">
<h3><a class="doc-anchor" href="#doc-not-elem">#</a> <code>not_elem</code></h3>
<p><code>not_elem</code> — haskell list functions builtin.</p>
<pre><code class="lang-perl">my $result = not_elem $x
# or in a pipeline:
@list |> map not_elem |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-not-every">
<h3><a class="doc-anchor" href="#doc-not-every">#</a> <code>not_every</code></h3>
<p><code>not_every</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = not_every $x
# or in a pipeline:
@list |> map not_every |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-now">
<h3><a class="doc-anchor" href="#doc-now">#</a> <code>now</code></h3>
<p><code>now</code> — date / time builtin. Alias for <code>datetime_now_tz</code>.</p>
<pre><code class="lang-perl">my $result = now $x
# or in a pipeline:
@list |> map now |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-now-ms">
<h3><a class="doc-anchor" href="#doc-now-ms">#</a> <code>now_ms</code></h3>
<p><code>now_ms</code> — now / timestamp builtin.</p>
<pre><code class="lang-perl">my $result = now_ms $x
# or in a pipeline:
@list |> map now_ms |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-now-ns">
<h3><a class="doc-anchor" href="#doc-now-ns">#</a> <code>now_ns</code></h3>
<p><code>now_ns</code> — now / timestamp builtin.</p>
<pre><code class="lang-perl">my $result = now_ns $x
# or in a pipeline:
@list |> map now_ns |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-now-us">
<h3><a class="doc-anchor" href="#doc-now-us">#</a> <code>now_us</code></h3>
<p><code>now_us</code> — now / timestamp builtin.</p>
<pre><code class="lang-perl">my $result = now_us $x
# or in a pipeline:
@list |> map now_us |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nper">
<h3><a class="doc-anchor" href="#doc-nper">#</a> <code>nper</code></h3>
<p><code>nper($rate, $pmt, $pv)</code> (alias <code>num_periods</code>) — computes the number of periods needed to pay off a loan given rate, payment, and principal.</p>
<pre><code class="lang-perl">p nper(0.05/12, 500, 50000) # ~127 months
</code></pre>
</article>
<article class="doc-entry" id="doc-npv">
<h3><a class="doc-anchor" href="#doc-npv">#</a> <code>npv</code></h3>
<p><code>npv</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = npv $x
# or in a pipeline:
@list |> map npv |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nrmrng">
<h3><a class="doc-anchor" href="#doc-nrmrng">#</a> <code>nrmrng</code></h3>
<p><code>nrmrng</code> — matrix operations (uncategorized batch) builtin. Alias for <code>normalize_range</code>.</p>
<pre><code class="lang-perl">my $result = nrmrng $x
# or in a pipeline:
@list |> map nrmrng |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nrmsp">
<h3><a class="doc-anchor" href="#doc-nrmsp">#</a> <code>nrmsp</code></h3>
<p><code>nrmsp</code> — extended stdlib builtin. Alias for <code>normalize_spaces</code>.</p>
<pre><code class="lang-perl">my $result = nrmsp $x
# or in a pipeline:
@list |> map nrmsp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nrmv">
<h3><a class="doc-anchor" href="#doc-nrmv">#</a> <code>nrmv</code></h3>
<p><code>nrmv</code> — extended stdlib builtin. Alias for <code>normalize_vec</code>.</p>
<pre><code class="lang-perl">my $result = nrmv $x
# or in a pipeline:
@list |> map nrmv |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nroot">
<h3><a class="doc-anchor" href="#doc-nroot">#</a> <code>nroot</code></h3>
<p><code>nroot</code> — extended stdlib builtin. Alias for <code>nth_root_of</code>.</p>
<pre><code class="lang-perl">my $result = nroot $x
# or in a pipeline:
@list |> map nroot |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nrow">
<h3><a class="doc-anchor" href="#doc-nrow">#</a> <code>nrow</code></h3>
<p><code>nrow</code> — number of rows in a matrix.</p>
<pre><code class="lang-perl">p nrow([[1,2],[3,4],[5,6]]) # 3
</code></pre>
</article>
<article class="doc-entry" id="doc-ns-to-ms">
<h3><a class="doc-anchor" href="#doc-ns-to-ms">#</a> <code>ns_to_ms</code></h3>
<p><code>ns_to_ms</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = ns_to_ms $input
</code></pre>
</article>
<article class="doc-entry" id="doc-ns-to-us">
<h3><a class="doc-anchor" href="#doc-ns-to-us">#</a> <code>ns_to_us</code></h3>
<p><code>ns_to_us</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = ns_to_us $input
</code></pre>
</article>
<article class="doc-entry" id="doc-ntelm">
<h3><a class="doc-anchor" href="#doc-ntelm">#</a> <code>ntelm</code></h3>
<p><code>ntelm</code> — haskell list functions builtin. Alias for <code>not_elem</code>.</p>
<pre><code class="lang-perl">my $result = ntelm $x
# or in a pipeline:
@list |> map ntelm |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nth-prime">
<h3><a class="doc-anchor" href="#doc-nth-prime">#</a> <code>nth_prime</code></h3>
<p><code>nth_prime</code> — number theory / primes builtin.</p>
<pre><code class="lang-perl">my $result = nth_prime $x
# or in a pipeline:
@list |> map nth_prime |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nth-root">
<h3><a class="doc-anchor" href="#doc-nth-root">#</a> <code>nth_root</code></h3>
<p><code>nth_root</code> — math functions builtin.</p>
<pre><code class="lang-perl">my $result = nth_root $x
# or in a pipeline:
@list |> map nth_root |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nth-root-of">
<h3><a class="doc-anchor" href="#doc-nth-root-of">#</a> <code>nth_root_of</code></h3>
<p><code>nth_root_of</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = nth_root_of $x
# or in a pipeline:
@list |> map nth_root_of |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nth-word">
<h3><a class="doc-anchor" href="#doc-nth-word">#</a> <code>nth_word</code></h3>
<p><code>nth_word</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = nth_word $x
# or in a pipeline:
@list |> map nth_word |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nthp">
<h3><a class="doc-anchor" href="#doc-nthp">#</a> <code>nthp</code></h3>
<p><code>nthp</code> — number theory / primes builtin. Alias for <code>nth_prime</code>.</p>
<pre><code class="lang-perl">my $result = nthp $x
# or in a pipeline:
@list |> map nthp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nub">
<h3><a class="doc-anchor" href="#doc-nub">#</a> <code>nub</code></h3>
<p><code>nub</code> — haskell list functions builtin.</p>
<pre><code class="lang-perl">my $result = nub $x
# or in a pipeline:
@list |> map nub |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nub-by">
<h3><a class="doc-anchor" href="#doc-nub-by">#</a> <code>nub_by</code></h3>
<p><code>nub_by</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = nub_by $x
# or in a pipeline:
@list |> map nub_by |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nubb">
<h3><a class="doc-anchor" href="#doc-nubb">#</a> <code>nubb</code></h3>
<p><code>nubb</code> — additional missing stdlib functions builtin. Alias for <code>nub_by</code>.</p>
<pre><code class="lang-perl">my $result = nubb $x
# or in a pipeline:
@list |> map nubb |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nuclear-magneton">
<h3><a class="doc-anchor" href="#doc-nuclear-magneton">#</a> <code>nuclear_magneton</code></h3>
<p><code>nuclear_magneton</code> — physics constants builtin.</p>
<pre><code class="lang-perl">my $result = nuclear_magneton $x
# or in a pipeline:
@list |> map nuclear_magneton |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-num-cpus">
<h3><a class="doc-anchor" href="#doc-num-cpus">#</a> <code>num_cpus</code></h3>
<p><code>num_cpus</code> — system introspection builtin.</p>
<pre><code class="lang-perl">my $result = num_cpus $x
# or in a pipeline:
@list |> map num_cpus |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-num-divisors">
<h3><a class="doc-anchor" href="#doc-num-divisors">#</a> <code>num_divisors</code></h3>
<p><code>num_divisors</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = num_divisors $x
# or in a pipeline:
@list |> map num_divisors |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-numeric-count">
<h3><a class="doc-anchor" href="#doc-numeric-count">#</a> <code>numeric_count</code></h3>
<p><code>numeric_count</code> — counters (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = numeric_count $x
# or in a pipeline:
@list |> map numeric_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nxtp">
<h3><a class="doc-anchor" href="#doc-nxtp">#</a> <code>nxtp</code></h3>
<p><code>nxtp</code> — number theory / primes builtin. Alias for <code>next_prime</code>.</p>
<pre><code class="lang-perl">my $result = nxtp $x
# or in a pipeline:
@list |> map nxtp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-nxtperm">
<h3><a class="doc-anchor" href="#doc-nxtperm">#</a> <code>nxtperm</code></h3>
<p><code>nxtperm</code> — matrix operations (uncategorized batch) builtin. Alias for <code>next_permutation</code>.</p>
<pre><code class="lang-perl">my $result = nxtperm $x
# or in a pipeline:
@list |> map nxtperm |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-object-entries">
<h3><a class="doc-anchor" href="#doc-object-entries">#</a> <code>object_entries</code></h3>
<p><code>object_entries</code> — javascript array/object methods builtin.</p>
<pre><code class="lang-perl">my $result = object_entries $x
# or in a pipeline:
@list |> map object_entries |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-object-from-entries">
<h3><a class="doc-anchor" href="#doc-object-from-entries">#</a> <code>object_from_entries</code></h3>
<p><code>object_from_entries</code> — javascript array/object methods builtin.</p>
<pre><code class="lang-perl">my $result = object_from_entries $x
# or in a pipeline:
@list |> map object_from_entries |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-object-keys">
<h3><a class="doc-anchor" href="#doc-object-keys">#</a> <code>object_keys</code></h3>
<p><code>object_keys</code> — javascript array/object methods builtin.</p>
<pre><code class="lang-perl">my $result = object_keys $x
# or in a pipeline:
@list |> map object_keys |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-object-values">
<h3><a class="doc-anchor" href="#doc-object-values">#</a> <code>object_values</code></h3>
<p><code>object_values</code> — javascript array/object methods builtin.</p>
<pre><code class="lang-perl">my $result = object_values $x
# or in a pipeline:
@list |> map object_values |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-oct-of">
<h3><a class="doc-anchor" href="#doc-oct-of">#</a> <code>oct_of</code></h3>
<p><code>oct_of</code> — base conversion builtin. Alias for <code>to_oct</code>.</p>
<pre><code class="lang-perl">my $result = oct_of $x
# or in a pipeline:
@list |> map oct_of |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-odd">
<h3><a class="doc-anchor" href="#doc-odd">#</a> <code>odd</code></h3>
<p><code>odd</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = odd $x
# or in a pipeline:
@list |> map odd |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-oents">
<h3><a class="doc-anchor" href="#doc-oents">#</a> <code>oents</code></h3>
<p><code>oents</code> — javascript array/object methods builtin. Alias for <code>object_entries</code>.</p>
<pre><code class="lang-perl">my $result = oents $x
# or in a pipeline:
@list |> map oents |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ofents">
<h3><a class="doc-anchor" href="#doc-ofents">#</a> <code>ofents</code></h3>
<p><code>ofents</code> — javascript array/object methods builtin. Alias for <code>object_from_entries</code>.</p>
<pre><code class="lang-perl">my $result = ofents $x
# or in a pipeline:
@list |> map ofents |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-off">
<h3><a class="doc-anchor" href="#doc-off">#</a> <code>off</code></h3>
<p><code>off</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = off $x
# or in a pipeline:
@list |> map off |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-offset-each">
<h3><a class="doc-anchor" href="#doc-offset-each">#</a> <code>offset_each</code></h3>
<p><code>offset_each</code> — trivial numeric helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = offset_each $x
# or in a pipeline:
@list |> map offset_each |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ohms-law-i">
<h3><a class="doc-anchor" href="#doc-ohms-law-i">#</a> <code>ohms_law_i</code></h3>
<p><code>ohms_law_i</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = ohms_law_i $x
# or in a pipeline:
@list |> map ohms_law_i |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ohms-law-r">
<h3><a class="doc-anchor" href="#doc-ohms-law-r">#</a> <code>ohms_law_r</code></h3>
<p><code>ohms_law_r</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = ohms_law_r $x
# or in a pipeline:
@list |> map ohms_law_r |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ohms-law-v">
<h3><a class="doc-anchor" href="#doc-ohms-law-v">#</a> <code>ohms_law_v</code></h3>
<p><code>ohms_law_v</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = ohms_law_v $x
# or in a pipeline:
@list |> map ohms_law_v |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-okeys">
<h3><a class="doc-anchor" href="#doc-okeys">#</a> <code>okeys</code></h3>
<p><code>okeys</code> — javascript array/object methods builtin. Alias for <code>object_keys</code>.</p>
<pre><code class="lang-perl">my $result = okeys $x
# or in a pipeline:
@list |> map okeys |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-omit">
<h3><a class="doc-anchor" href="#doc-omit">#</a> <code>omit</code></h3>
<p><code>omit</code> — hash ops (batch 2) builtin. Alias for <code>omit_keys</code>.</p>
<pre><code class="lang-perl">my $result = omit $x
# or in a pipeline:
@list |> map omit |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-omit-keys">
<h3><a class="doc-anchor" href="#doc-omit-keys">#</a> <code>omit_keys</code></h3>
<p><code>omit_keys</code> — hash ops (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = omit_keys $x
# or in a pipeline:
@list |> map omit_keys |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-one">
<h3><a class="doc-anchor" href="#doc-one">#</a> <code>one</code></h3>
<p><code>one</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = one $x
# or in a pipeline:
@list |> map one |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ones">
<h3><a class="doc-anchor" href="#doc-ones">#</a> <code>ones</code></h3>
<p><code>ones</code> — matrix / linear algebra builtin.</p>
<pre><code class="lang-perl">my $result = ones $x
# or in a pipeline:
@list |> map ones |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ones-mat">
<h3><a class="doc-anchor" href="#doc-ones-mat">#</a> <code>ones_mat</code></h3>
<p><code>ones_mat</code> — matrix / linear algebra builtin. Alias for <code>ones_matrix</code>.</p>
<pre><code class="lang-perl">my $result = ones_mat $x
# or in a pipeline:
@list |> map ones_mat |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ones-matrix">
<h3><a class="doc-anchor" href="#doc-ones-matrix">#</a> <code>ones_matrix</code></h3>
<p><code>ones_matrix</code> — matrix / linear algebra builtin.</p>
<pre><code class="lang-perl">my $result = ones_matrix $x
# or in a pipeline:
@list |> map ones_matrix |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-only-alnum">
<h3><a class="doc-anchor" href="#doc-only-alnum">#</a> <code>only_alnum</code></h3>
<p><code>only_alnum</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = only_alnum $x
# or in a pipeline:
@list |> map only_alnum |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-only-alpha">
<h3><a class="doc-anchor" href="#doc-only-alpha">#</a> <code>only_alpha</code></h3>
<p><code>only_alpha</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = only_alpha $x
# or in a pipeline:
@list |> map only_alpha |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-only-ascii">
<h3><a class="doc-anchor" href="#doc-only-ascii">#</a> <code>only_ascii</code></h3>
<p><code>only_ascii</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = only_ascii $x
# or in a pipeline:
@list |> map only_ascii |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-only-digits">
<h3><a class="doc-anchor" href="#doc-only-digits">#</a> <code>only_digits</code></h3>
<p><code>only_digits</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = only_digits $x
# or in a pipeline:
@list |> map only_digits |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-or">
<h3><a class="doc-anchor" href="#doc-or">#</a> <code>or</code></h3>
<p><code>or</code> — control flow builtin.</p>
<pre><code class="lang-perl">my $result = or $x
# or in a pipeline:
@list |> map or |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-or-list">
<h3><a class="doc-anchor" href="#doc-or-list">#</a> <code>or_list</code></h3>
<p><code>or_list</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = or_list $x
# or in a pipeline:
@list |> map or_list |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-orbital-period">
<h3><a class="doc-anchor" href="#doc-orbital-period">#</a> <code>orbital_period</code></h3>
<p><code>orbital_period($mass, $radius)</code> (alias <code>orbper</code>) — period for circular orbit: T = 2π√(r³/GM). Returns seconds.</p>
<pre><code class="lang-perl">my $t = orbper # ~5560 s (ISS orbital period)
p $t / 60 # ~93 minutes
</code></pre>
</article>
<article class="doc-entry" id="doc-orbital-velocity">
<h3><a class="doc-anchor" href="#doc-orbital-velocity">#</a> <code>orbital_velocity</code></h3>
<p><code>orbital_velocity($mass, $radius)</code> (alias <code>orbvel</code>) — velocity for circular orbit: v = √(GM/r). Defaults to LEO around Earth.</p>
<pre><code class="lang-perl">p orbvel # ~7672 m/s (ISS orbital speed)
</code></pre>
</article>
<article class="doc-entry" id="doc-ordered-set">
<h3><a class="doc-anchor" href="#doc-ordered-set">#</a> <code>ordered_set</code></h3>
<p><code>ordered_set</code> — data structure helpers builtin.</p>
<pre><code class="lang-perl">my $result = ordered_set $x
# or in a pipeline:
@list |> map ordered_set |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ordinalize">
<h3><a class="doc-anchor" href="#doc-ordinalize">#</a> <code>ordinalize</code></h3>
<p><code>ordinalize</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = ordinalize $x
# or in a pipeline:
@list |> map ordinalize |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ordn">
<h3><a class="doc-anchor" href="#doc-ordn">#</a> <code>ordn</code></h3>
<p><code>ordn</code> — extended stdlib builtin. Alias for <code>ordinalize</code>.</p>
<pre><code class="lang-perl">my $result = ordn $x
# or in a pipeline:
@list |> map ordn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-orl">
<h3><a class="doc-anchor" href="#doc-orl">#</a> <code>orl</code></h3>
<p><code>orl</code> — additional missing stdlib functions builtin. Alias for <code>or_list</code>.</p>
<pre><code class="lang-perl">my $result = orl $x
# or in a pipeline:
@list |> map orl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-arch">
<h3><a class="doc-anchor" href="#doc-os-arch">#</a> <code>os_arch</code></h3>
<p><code>os_arch</code> — system introspection builtin.</p>
<pre><code class="lang-perl">my $result = os_arch $x
# or in a pipeline:
@list |> map os_arch |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-family">
<h3><a class="doc-anchor" href="#doc-os-family">#</a> <code>os_family</code></h3>
<p><code>os_family</code> — OS family string: <code>"unix"</code> or <code>"windows"</code>. From <code>std::env::consts::FAMILY</code>.</p>
<pre><code class="lang-perl">p os_family # unix
die "unix only" unless os_family eq "unix"
</code></pre>
</article>
<article class="doc-entry" id="doc-os-name">
<h3><a class="doc-anchor" href="#doc-os-name">#</a> <code>os_name</code></h3>
<p><code>os_name</code> — system introspection builtin.</p>
<pre><code class="lang-perl">my $result = os_name $x
# or in a pipeline:
@list |> map os_name |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-os-version">
<h3><a class="doc-anchor" href="#doc-os-version">#</a> <code>os_version</code></h3>
<p><code>os_version</code> — OS kernel version/release string from <code>uname</code>. Returns <code>undef</code> on non-unix.</p>
<pre><code class="lang-perl">p os_version # 25.4.0
p "kernel: " . os_version
</code></pre>
</article>
<article class="doc-entry" id="doc-outer">
<h3><a class="doc-anchor" href="#doc-outer">#</a> <code>outer</code></h3>
<p><code>outer</code> — outer product of two vectors. Returns matrix where M[i][j] = v1[i] * v2[j].</p>
<pre><code class="lang-perl">my $m = outer([1,2,3], [10,20]) # [[10,20],[20,40],[30,60]]
</code></pre>
</article>
<article class="doc-entry" id="doc-outliers">
<h3><a class="doc-anchor" href="#doc-outliers">#</a> <code>outliers</code></h3>
<p><code>outliers</code> — statistics (extended) builtin. Alias for <code>outliers_iqr</code>.</p>
<pre><code class="lang-perl">my $result = outliers $x
# or in a pipeline:
@list |> map outliers |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-outliers-iqr">
<h3><a class="doc-anchor" href="#doc-outliers-iqr">#</a> <code>outliers_iqr</code></h3>
<p><code>outliers_iqr(@data)</code> — identifies outliers using the IQR method (1.5 × IQR beyond Q1/Q3). Returns an arrayref of outlier values. Standard approach for detecting unusual data points.</p>
<pre><code class="lang-perl">my @data = (1, 2, 3, 4, 5, 100)
my $out = outliers_iqr(@data)
p @$out # (100)
</code></pre>
</article>
<article class="doc-entry" id="doc-ovals">
<h3><a class="doc-anchor" href="#doc-ovals">#</a> <code>ovals</code></h3>
<p><code>ovals</code> — javascript array/object methods builtin. Alias for <code>object_values</code>.</p>
<pre><code class="lang-perl">my $result = ovals $x
# or in a pipeline:
@list |> map ovals |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-overlap-coefficient">
<h3><a class="doc-anchor" href="#doc-overlap-coefficient">#</a> <code>overlap_coefficient</code></h3>
<p><code>overlap_coefficient</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = overlap_coefficient $x
# or in a pipeline:
@list |> map overlap_coefficient |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-overlapcoef">
<h3><a class="doc-anchor" href="#doc-overlapcoef">#</a> <code>overlapcoef</code></h3>
<p><code>overlapcoef</code> — extended stdlib batch 3 builtin. Alias for <code>overlap_coefficient</code>.</p>
<pre><code class="lang-perl">my $result = overlapcoef $x
# or in a pipeline:
@list |> map overlapcoef |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-overline">
<h3><a class="doc-anchor" href="#doc-overline">#</a> <code>overline</code></h3>
<p><code>overline</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = overline $x
# or in a pipeline:
@list |> map overline |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-oz-to-g">
<h3><a class="doc-anchor" href="#doc-oz-to-g">#</a> <code>oz_to_g</code></h3>
<p><code>oz_to_g</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = oz_to_g $input
</code></pre>
</article>
<article class="doc-entry" id="doc-pacf">
<h3><a class="doc-anchor" href="#doc-pacf">#</a> <code>pacf</code></h3>
<p><code>pacf_fn</code> (alias <code>pacf</code>) — partial autocorrelation function via Durbin-Levinson. Like R's pacf().</p>
<pre><code class="lang-perl">my @pa = @{pacf([1,3,2,4,3,5], 3)}
</code></pre>
</article>
<article class="doc-entry" id="doc-pad-left">
<h3><a class="doc-anchor" href="#doc-pad-left">#</a> <code>pad_left</code></h3>
<p><code>pad_left</code> — trivial string ops builtin.</p>
<pre><code class="lang-perl">my $result = pad_left $x
# or in a pipeline:
@list |> map pad_left |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pad-number">
<h3><a class="doc-anchor" href="#doc-pad-number">#</a> <code>pad_number</code></h3>
<p><code>pad_number</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = pad_number $x
# or in a pipeline:
@list |> map pad_number |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pad-right">
<h3><a class="doc-anchor" href="#doc-pad-right">#</a> <code>pad_right</code></h3>
<p><code>pad_right</code> — trivial string ops builtin.</p>
<pre><code class="lang-perl">my $result = pad_right $x
# or in a pipeline:
@list |> map pad_right |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-page-size">
<h3><a class="doc-anchor" href="#doc-page-size">#</a> <code>page_size</code></h3>
<p><code>page_size</code> — memory page size in bytes. Uses <code>sysconf(_SC_PAGESIZE)</code> on unix.</p>
<pre><code class="lang-perl">p page_size # 16384 (Apple Silicon)
p page_size # 4096 (x86_64)
</code></pre>
</article>
<article class="doc-entry" id="doc-paired-ttest">
<h3><a class="doc-anchor" href="#doc-paired-ttest">#</a> <code>paired_ttest</code></h3>
<p><code>paired_ttest</code> (alias <code>pairedt</code>) performs a paired t-test on two matched samples. Returns [t-statistic, degrees of freedom].</p>
<pre><code class="lang-perl">my ($t, $df) = @{pairedt([85,90,78], [88,92,80])}
</code></pre>
</article>
<article class="doc-entry" id="doc-pairs-from-hash">
<h3><a class="doc-anchor" href="#doc-pairs-from-hash">#</a> <code>pairs_from_hash</code></h3>
<p><code>pairs_from_hash</code> — hash ops (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = pairs_from_hash $x
# or in a pipeline:
@list |> map pairs_from_hash |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pairwise">
<h3><a class="doc-anchor" href="#doc-pairwise">#</a> <code>pairwise</code></h3>
<p><code>pairwise</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = pairwise $x
# or in a pipeline:
@list |> map pairwise |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pairwise-iter">
<h3><a class="doc-anchor" href="#doc-pairwise-iter">#</a> <code>pairwise_iter</code></h3>
<p><code>pairwise_iter</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = pairwise_iter $x
# or in a pipeline:
@list |> map pairwise_iter |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pall">
<h3><a class="doc-anchor" href="#doc-pall">#</a> <code>pall</code></h3>
<p><code>pall</code> — algebraic match builtin. Alias for <code>partition_all</code>.</p>
<pre><code class="lang-perl">my $result = pall $x
# or in a pipeline:
@list |> map pall |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-parenthesize">
<h3><a class="doc-anchor" href="#doc-parenthesize">#</a> <code>parenthesize</code></h3>
<p><code>parenthesize</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = parenthesize $x
# or in a pipeline:
@list |> map parenthesize |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pareto-pdf">
<h3><a class="doc-anchor" href="#doc-pareto-pdf">#</a> <code>pareto_pdf</code></h3>
<p><code>pareto_pdf</code> (alias <code>paretopdf</code>) evaluates the Pareto distribution PDF at x with minimum xm and shape alpha.</p>
<pre><code class="lang-perl">p paretopdf(2, 1, 3) # Pareto(1,3) at x=2
</code></pre>
</article>
<article class="doc-entry" id="doc-parse-bool">
<h3><a class="doc-anchor" href="#doc-parse-bool">#</a> <code>parse_bool</code></h3>
<p><code>parse_bool</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = parse_bool $x
# or in a pipeline:
@list |> map parse_bool |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-parse-float">
<h3><a class="doc-anchor" href="#doc-parse-float">#</a> <code>parse_float</code></h3>
<p><code>parse_float</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = parse_float $x
# or in a pipeline:
@list |> map parse_float |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-parse-int">
<h3><a class="doc-anchor" href="#doc-parse-int">#</a> <code>parse_int</code></h3>
<p><code>parse_int</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = parse_int $x
# or in a pipeline:
@list |> map parse_int |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-parsec">
<h3><a class="doc-anchor" href="#doc-parsec">#</a> <code>parsec</code></h3>
<p><code>parsec</code> (alias <code>pc</code>) — pc ≈ 3.086×10¹⁶ m ≈ 3.26 ly. Common astronomical distance unit.</p>
<pre><code class="lang-perl">p pc # 3.0856775814913673e16 m
p pc / ly # ~3.26 light years
</code></pre>
</article>
<article class="doc-entry" id="doc-partition-all">
<h3><a class="doc-anchor" href="#doc-partition-all">#</a> <code>partition_all</code></h3>
<p><code>partition_all</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = partition_all $x
# or in a pipeline:
@list |> map partition_all |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-partition-by">
<h3><a class="doc-anchor" href="#doc-partition-by">#</a> <code>partition_by</code></h3>
<p><code>partition_by</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = partition_by $x
# or in a pipeline:
@list |> map partition_by |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-partition-either">
<h3><a class="doc-anchor" href="#doc-partition-either">#</a> <code>partition_either</code></h3>
<p><code>partition_either</code> — rust iterator methods builtin.</p>
<pre><code class="lang-perl">my $result = partition_either $x
# or in a pipeline:
@list |> map partition_either |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-partition-n">
<h3><a class="doc-anchor" href="#doc-partition-n">#</a> <code>partition_n</code></h3>
<p><code>partition_n</code> — go/general functional utilities builtin.</p>
<pre><code class="lang-perl">my $result = partition_n $x
# or in a pipeline:
@list |> map partition_n |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-partition-number">
<h3><a class="doc-anchor" href="#doc-partition-number">#</a> <code>partition_number</code></h3>
<p><code>partition_number</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = partition_number $x
# or in a pipeline:
@list |> map partition_number |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-partition-point">
<h3><a class="doc-anchor" href="#doc-partition-point">#</a> <code>partition_point</code></h3>
<p><code>partition_point</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = partition_point $x
# or in a pipeline:
@list |> map partition_point |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-partition-two">
<h3><a class="doc-anchor" href="#doc-partition-two">#</a> <code>partition_two</code></h3>
<p><code>partition_two</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = partition_two $x
# or in a pipeline:
@list |> map partition_two |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-partn">
<h3><a class="doc-anchor" href="#doc-partn">#</a> <code>partn</code></h3>
<p><code>partn</code> — go/general functional utilities builtin. Alias for <code>partition_n</code>.</p>
<pre><code class="lang-perl">my $result = partn $x
# or in a pipeline:
@list |> map partn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-partn-num">
<h3><a class="doc-anchor" href="#doc-partn-num">#</a> <code>partn_num</code></h3>
<p><code>partn_num</code> — math / numeric (uncategorized batch) builtin. Alias for <code>partition_number</code>.</p>
<pre><code class="lang-perl">my $result = partn_num $x
# or in a pipeline:
@list |> map partn_num |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pascal-case">
<h3><a class="doc-anchor" href="#doc-pascal-case">#</a> <code>pascal_case</code></h3>
<p><code>pascal_case</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = pascal_case $x
# or in a pipeline:
@list |> map pascal_case |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pascal-row">
<h3><a class="doc-anchor" href="#doc-pascal-row">#</a> <code>pascal_row</code></h3>
<p><code>pascal_row</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = pascal_row $x
# or in a pipeline:
@list |> map pascal_row |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pascals-to-bar">
<h3><a class="doc-anchor" href="#doc-pascals-to-bar">#</a> <code>pascals_to_bar</code></h3>
<p><code>pascals_to_bar</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = pascals_to_bar $input
</code></pre>
</article>
<article class="doc-entry" id="doc-pascals-to-psi">
<h3><a class="doc-anchor" href="#doc-pascals-to-psi">#</a> <code>pascals_to_psi</code></h3>
<p><code>pascals_to_psi</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = pascals_to_psi $input
</code></pre>
</article>
<article class="doc-entry" id="doc-pascals-triangle">
<h3><a class="doc-anchor" href="#doc-pascals-triangle">#</a> <code>pascals_triangle</code></h3>
<p><code>pascals_triangle</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = pascals_triangle $x
# or in a pipeline:
@list |> map pascals_triangle |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pascrow">
<h3><a class="doc-anchor" href="#doc-pascrow">#</a> <code>pascrow</code></h3>
<p><code>pascrow</code> — extended stdlib batch 3 builtin. Alias for <code>pascal_row</code>.</p>
<pre><code class="lang-perl">my $result = pascrow $x
# or in a pipeline:
@list |> map pascrow |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pasctri">
<h3><a class="doc-anchor" href="#doc-pasctri">#</a> <code>pasctri</code></h3>
<p><code>pasctri</code> — math / numeric (uncategorized batch) builtin. Alias for <code>pascals_triangle</code>.</p>
<pre><code class="lang-perl">my $result = pasctri $x
# or in a pipeline:
@list |> map pasctri |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pass">
<h3><a class="doc-anchor" href="#doc-pass">#</a> <code>pass</code></h3>
<p><code>pass</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = pass $x
# or in a pipeline:
@list |> map pass |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-path-case">
<h3><a class="doc-anchor" href="#doc-path-case">#</a> <code>path_case</code></h3>
<p><code>path_case</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = path_case $x
# or in a pipeline:
@list |> map path_case |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-path-ext">
<h3><a class="doc-anchor" href="#doc-path-ext">#</a> <code>path_ext</code></h3>
<p><code>path_ext</code> — path helpers builtin.</p>
<pre><code class="lang-perl">my $result = path_ext $x
# or in a pipeline:
@list |> map path_ext |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-path-is-abs">
<h3><a class="doc-anchor" href="#doc-path-is-abs">#</a> <code>path_is_abs</code></h3>
<p><code>path_is_abs</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = path_is_abs $x
# or in a pipeline:
@list |> map path_is_abs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-path-is-rel">
<h3><a class="doc-anchor" href="#doc-path-is-rel">#</a> <code>path_is_rel</code></h3>
<p><code>path_is_rel</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = path_is_rel $x
# or in a pipeline:
@list |> map path_is_rel |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-path-join">
<h3><a class="doc-anchor" href="#doc-path-join">#</a> <code>path_join</code></h3>
<p><code>path_join</code> — path helpers builtin.</p>
<pre><code class="lang-perl">my $result = path_join $x
# or in a pipeline:
@list |> map path_join |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-path-parent">
<h3><a class="doc-anchor" href="#doc-path-parent">#</a> <code>path_parent</code></h3>
<p><code>path_parent</code> — path helpers builtin.</p>
<pre><code class="lang-perl">my $result = path_parent $x
# or in a pipeline:
@list |> map path_parent |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-path-split">
<h3><a class="doc-anchor" href="#doc-path-split">#</a> <code>path_split</code></h3>
<p><code>path_split</code> — path helpers builtin.</p>
<pre><code class="lang-perl">my $result = path_split $x
# or in a pipeline:
@list |> map path_split |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-path-stem">
<h3><a class="doc-anchor" href="#doc-path-stem">#</a> <code>path_stem</code></h3>
<p><code>path_stem</code> — path helpers builtin.</p>
<pre><code class="lang-perl">my $result = path_stem $x
# or in a pipeline:
@list |> map path_stem |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-payback">
<h3><a class="doc-anchor" href="#doc-payback">#</a> <code>payback</code></h3>
<p><code>payback_period($initial, @cashflows)</code> (alias <code>payback</code>) — computes the number of periods to recover initial investment. Returns fractional periods.</p>
<pre><code class="lang-perl">p payback(1000, 300, 400, 500) # 2.6 periods
</code></pre>
</article>
<article class="doc-entry" id="doc-pbeta">
<h3><a class="doc-anchor" href="#doc-pbeta">#</a> <code>pbeta</code></h3>
<p><code>pbeta</code> — beta CDF (regularized incomplete beta). Args: x, a, b.</p>
<pre><code class="lang-perl">p pbeta(0.5, 2, 5) # P(X ≤ 0.5) for Beta(2,5)
</code></pre>
</article>
<article class="doc-entry" id="doc-pbinom">
<h3><a class="doc-anchor" href="#doc-pbinom">#</a> <code>pbinom</code></h3>
<p><code>pbinom</code> — binomial CDF. P(X ≤ k) for Binom(n, p). Args: k, n, p.</p>
<pre><code class="lang-perl">p pbinom(5, 10, 0.5) # P(≤5 heads in 10 flips)
</code></pre>
</article>
<article class="doc-entry" id="doc-pbool">
<h3><a class="doc-anchor" href="#doc-pbool">#</a> <code>pbool</code></h3>
<p><code>pbool</code> — extended stdlib builtin. Alias for <code>parse_bool</code>.</p>
<pre><code class="lang-perl">my $result = pbool $x
# or in a pipeline:
@list |> map pbool |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pby">
<h3><a class="doc-anchor" href="#doc-pby">#</a> <code>pby</code></h3>
<p><code>pby</code> — algebraic match builtin. Alias for <code>partition_by</code>.</p>
<pre><code class="lang-perl">my $result = pby $x
# or in a pipeline:
@list |> map pby |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pc-case">
<h3><a class="doc-anchor" href="#doc-pc-case">#</a> <code>pc_case</code></h3>
<p><code>pc_case</code> — string (batch 2) builtin. Alias for <code>pascal_case</code>.</p>
<pre><code class="lang-perl">my $result = pc_case $x
# or in a pipeline:
@list |> map pc_case |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pca">
<h3><a class="doc-anchor" href="#doc-pca">#</a> <code>pca</code></h3>
<p><code>prcomp</code> (alias <code>pca</code>) — Principal Component Analysis via eigendecomposition of covariance matrix. Returns eigenvalues (variance explained). Like R's prcomp().</p>
<pre><code class="lang-perl">my @var = @{pca([[1,2],[3,4],[5,6],[7,8]])}
# variance explained by each component
</code></pre>
</article>
<article class="doc-entry" id="doc-pcauchy">
<h3><a class="doc-anchor" href="#doc-pcauchy">#</a> <code>pcauchy</code></h3>
<p><code>pcauchy</code> — Cauchy CDF. P(X ≤ x). Args: x [, location, scale].</p>
<pre><code class="lang-perl">p pcauchy(0, 0, 1) # 0.5
</code></pre>
</article>
<article class="doc-entry" id="doc-pchisq">
<h3><a class="doc-anchor" href="#doc-pchisq">#</a> <code>pchisq</code></h3>
<p><code>pchisq</code> — chi-squared CDF. Args: x, df.</p>
<pre><code class="lang-perl">p pchisq(3.84, 1) # 0.95 (critical value for p=0.05)
</code></pre>
</article>
<article class="doc-entry" id="doc-pcr">
<h3><a class="doc-anchor" href="#doc-pcr">#</a> <code>pcr</code></h3>
<p><code>pcr</code> — data / network builtin. Alias for <code>par_csv_read</code>.</p>
<pre><code class="lang-perl">my $result = pcr $x
# or in a pipeline:
@list |> map pcr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pct">
<h3><a class="doc-anchor" href="#doc-pct">#</a> <code>pct</code></h3>
<p><code>pct</code> — trivial numeric / predicate builtins builtin. Alias for <code>percent</code>.</p>
<pre><code class="lang-perl">my $result = pct $x
# or in a pipeline:
@list |> map pct |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pctrank">
<h3><a class="doc-anchor" href="#doc-pctrank">#</a> <code>pctrank</code></h3>
<p><code>pctrank</code> — statistics (extended) builtin. Alias for <code>percentile_rank</code>.</p>
<pre><code class="lang-perl">my $result = pctrank $x
# or in a pipeline:
@list |> map pctrank |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-peak-detect">
<h3><a class="doc-anchor" href="#doc-peak-detect">#</a> <code>peak_detect</code></h3>
<p><code>peak_detect</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = peak_detect $x
# or in a pipeline:
@list |> map peak_detect |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-peaks">
<h3><a class="doc-anchor" href="#doc-peaks">#</a> <code>peaks</code></h3>
<p><code>peaks</code> — matrix operations (uncategorized batch) builtin. Alias for <code>peak_detect</code>.</p>
<pre><code class="lang-perl">my $result = peaks $x
# or in a pipeline:
@list |> map peaks |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-peek-clj">
<h3><a class="doc-anchor" href="#doc-peek-clj">#</a> <code>peek_clj</code></h3>
<p><code>peek_clj</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = peek_clj $x
# or in a pipeline:
@list |> map peek_clj |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-peith">
<h3><a class="doc-anchor" href="#doc-peith">#</a> <code>peith</code></h3>
<p><code>peith</code> — rust iterator methods builtin. Alias for <code>partition_either</code>.</p>
<pre><code class="lang-perl">my $result = peith $x
# or in a pipeline:
@list |> map peith |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pendper">
<h3><a class="doc-anchor" href="#doc-pendper">#</a> <code>pendper</code></h3>
<p><code>pendulum_period($length)</code> (alias <code>pendper</code>) — period T = 2π√(L/g) of a simple pendulum.</p>
<pre><code class="lang-perl">p pendper(1) # ~2.01 s (1 meter pendulum)
p pendper(0.25) # ~1.00 s (grandfather clock)
</code></pre>
</article>
<article class="doc-entry" id="doc-pentagonal-number">
<h3><a class="doc-anchor" href="#doc-pentagonal-number">#</a> <code>pentagonal_number</code></h3>
<p><code>pentagonal_number</code> — number theory / primes builtin.</p>
<pre><code class="lang-perl">my $result = pentagonal_number $x
# or in a pipeline:
@list |> map pentagonal_number |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pentnum">
<h3><a class="doc-anchor" href="#doc-pentnum">#</a> <code>pentnum</code></h3>
<p><code>pentnum</code> — number theory / primes builtin. Alias for <code>pentagonal_number</code>.</p>
<pre><code class="lang-perl">my $result = pentnum $x
# or in a pipeline:
@list |> map pentnum |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-percent">
<h3><a class="doc-anchor" href="#doc-percent">#</a> <code>percent</code></h3>
<p><code>percent</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = percent $x
# or in a pipeline:
@list |> map percent |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-percentile">
<h3><a class="doc-anchor" href="#doc-percentile">#</a> <code>percentile</code></h3>
<p><code>percentile</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = percentile $x
# or in a pipeline:
@list |> map percentile |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-percentile-rank">
<h3><a class="doc-anchor" href="#doc-percentile-rank">#</a> <code>percentile_rank</code></h3>
<p><code>percentile_rank($value, @data)</code> — returns the percentile rank (0-100) of a value within a dataset. Indicates what percentage of the data falls below the given value. Useful for ranking and normalization.</p>
<pre><code class="lang-perl">my @scores = 1..100
p percentile_rank(50, @scores) # ~50
p percentile_rank(90, @scores) # ~90
</code></pre>
</article>
<article class="doc-entry" id="doc-perfect-numbers">
<h3><a class="doc-anchor" href="#doc-perfect-numbers">#</a> <code>perfect_numbers</code></h3>
<p><code>perfect_numbers</code> — number theory / primes builtin.</p>
<pre><code class="lang-perl">my $result = perfect_numbers $x
# or in a pipeline:
@list |> map perfect_numbers |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-perfnums">
<h3><a class="doc-anchor" href="#doc-perfnums">#</a> <code>perfnums</code></h3>
<p><code>perfnums</code> — number theory / primes builtin. Alias for <code>perfect_numbers</code>.</p>
<pre><code class="lang-perl">my $result = perfnums $x
# or in a pipeline:
@list |> map perfnums |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-perimeter-rectangle">
<h3><a class="doc-anchor" href="#doc-perimeter-rectangle">#</a> <code>perimeter_rectangle</code></h3>
<p><code>perimeter_rectangle</code> — geometry / physics builtin.</p>
<pre><code class="lang-perl">my $result = perimeter_rectangle $x
# or in a pipeline:
@list |> map perimeter_rectangle |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-perimeter-triangle">
<h3><a class="doc-anchor" href="#doc-perimeter-triangle">#</a> <code>perimeter_triangle</code></h3>
<p><code>perimeter_triangle</code> — geometry / physics builtin.</p>
<pre><code class="lang-perl">my $result = perimeter_triangle $x
# or in a pipeline:
@list |> map perimeter_triangle |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-perm">
<h3><a class="doc-anchor" href="#doc-perm">#</a> <code>perm</code></h3>
<p><code>permutations($n, $r)</code> (alias <code>perm</code>) — number of ways to arrange r items from n. Formula: n!/(n-r)!. Order matters.</p>
<pre><code class="lang-perl">p perm(5, 3) # 60 (ways to arrange 3 items from 5)
p perm(10, 2) # 90
</code></pre>
</article>
<article class="doc-entry" id="doc-pexp">
<h3><a class="doc-anchor" href="#doc-pexp">#</a> <code>pexp</code></h3>
<p><code>pexp</code> — exponential CDF. P(X ≤ x) for Exp(rate). Args: x, rate.</p>
<pre><code class="lang-perl">p pexp(1, 1) # 0.6321 (1 - e^-1)
p pexp(5, 0.5) # P(wait ≤ 5 with avg wait 2)
</code></pre>
</article>
<article class="doc-entry" id="doc-pf">
<h3><a class="doc-anchor" href="#doc-pf">#</a> <code>pf</code></h3>
<p><code>pf</code> — F-distribution CDF. Args: x, d1, d2.</p>
<pre><code class="lang-perl">p pf(4.0, 5, 10) # P(F ≤ 4) for F(5,10)
</code></pre>
</article>
<article class="doc-entry" id="doc-pfact">
<h3><a class="doc-anchor" href="#doc-pfact">#</a> <code>pfact</code></h3>
<p><code>pfact</code> — number theory / primes builtin. Alias for <code>prime_factors</code>.</p>
<pre><code class="lang-perl">my $result = pfact $x
# or in a pipeline:
@list |> map pfact |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pflt">
<h3><a class="doc-anchor" href="#doc-pflt">#</a> <code>pflt</code></h3>
<p><code>pflt</code> — extended stdlib builtin. Alias for <code>parse_float</code>.</p>
<pre><code class="lang-perl">my $result = pflt $x
# or in a pipeline:
@list |> map pflt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pft">
<h3><a class="doc-anchor" href="#doc-pft">#</a> <code>pft</code></h3>
<p><code>pft</code> — data / network builtin. Alias for <code>par_fetch</code>.</p>
<pre><code class="lang-perl">my $result = pft $x
# or in a pipeline:
@list |> map pft |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pgamma">
<h3><a class="doc-anchor" href="#doc-pgamma">#</a> <code>pgamma</code></h3>
<p><code>pgamma</code> — gamma CDF. Args: x, shape [, scale].</p>
<pre><code class="lang-perl">p pgamma(2, 2, 1) # P(X ≤ 2) for Gamma(2,1)
</code></pre>
</article>
<article class="doc-entry" id="doc-phase-spectrum">
<h3><a class="doc-anchor" href="#doc-phase-spectrum">#</a> <code>phase_spectrum</code></h3>
<p><code>phase_spectrum(\@signal)</code> — computes the phase angle (in radians) at each frequency bin from the DFT.</p>
<pre><code class="lang-perl">my $phases = phase_spectrum(\@signal)
</code></pre>
</article>
<article class="doc-entry" id="doc-phasespec">
<h3><a class="doc-anchor" href="#doc-phasespec">#</a> <code>phasespec</code></h3>
<p><code>phasespec</code> — dsp / signal (extended) builtin. Alias for <code>phase_spectrum</code>.</p>
<pre><code class="lang-perl">my $result = phasespec $x
# or in a pipeline:
@list |> map phasespec |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-phonedigit">
<h3><a class="doc-anchor" href="#doc-phonedigit">#</a> <code>phonedigit</code></h3>
<p><code>phonedigit</code> — encoding / phonetics builtin. Alias for <code>phonetic_digit</code>.</p>
<pre><code class="lang-perl">my $result = phonedigit $x
# or in a pipeline:
@list |> map phonedigit |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-phonetic-digit">
<h3><a class="doc-anchor" href="#doc-phonetic-digit">#</a> <code>phonetic_digit</code></h3>
<p><code>phonetic_digit</code> — encoding / phonetics builtin.</p>
<pre><code class="lang-perl">my $result = phonetic_digit $x
# or in a pipeline:
@list |> map phonetic_digit |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-photon-energy">
<h3><a class="doc-anchor" href="#doc-photon-energy">#</a> <code>photon_energy</code></h3>
<p><code>photon_energy($frequency)</code> (alias <code>photonenergy</code>) — energy E = hf (Joules) of a photon.</p>
<pre><code class="lang-perl">p photonenergy(5e14) # ~3.3e-19 J (visible light)
</code></pre>
</article>
<article class="doc-entry" id="doc-photon-energy-wavelength">
<h3><a class="doc-anchor" href="#doc-photon-energy-wavelength">#</a> <code>photon_energy_wavelength</code></h3>
<p><code>photon_energy_wavelength</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = photon_energy_wavelength $x
# or in a pipeline:
@list |> map photon_energy_wavelength |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-photonlambda">
<h3><a class="doc-anchor" href="#doc-photonlambda">#</a> <code>photonlambda</code></h3>
<p><code>photonlambda</code> — physics formulas builtin. Alias for <code>photon_energy_wavelength</code>.</p>
<pre><code class="lang-perl">my $result = photonlambda $x
# or in a pipeline:
@list |> map photonlambda |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pi">
<h3><a class="doc-anchor" href="#doc-pi">#</a> <code>pi</code></h3>
<p><code>pi</code> — constants builtin.</p>
<pre><code class="lang-perl">my $result = pi $x
# or in a pipeline:
@list |> map pi |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pick">
<h3><a class="doc-anchor" href="#doc-pick">#</a> <code>pick</code></h3>
<p><code>pick</code> — hash ops (batch 2) builtin. Alias for <code>pick_keys</code>.</p>
<pre><code class="lang-perl">my $result = pick $x
# or in a pipeline:
@list |> map pick |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pick-keys">
<h3><a class="doc-anchor" href="#doc-pick-keys">#</a> <code>pick_keys</code></h3>
<p><code>pick_keys</code> — hash ops (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = pick_keys $x
# or in a pipeline:
@list |> map pick_keys |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pid">
<h3><a class="doc-anchor" href="#doc-pid">#</a> <code>pid</code></h3>
<p><code>pid</code> — system introspection builtin.</p>
<pre><code class="lang-perl">my $result = pid $x
# or in a pipeline:
@list |> map pid |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pig-latin">
<h3><a class="doc-anchor" href="#doc-pig-latin">#</a> <code>pig_latin</code></h3>
<p><code>pig_latin</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = pig_latin $x
# or in a pipeline:
@list |> map pig_latin |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-piglat">
<h3><a class="doc-anchor" href="#doc-piglat">#</a> <code>piglat</code></h3>
<p><code>piglat</code> — string processing (uncategorized batch) builtin. Alias for <code>pig_latin</code>.</p>
<pre><code class="lang-perl">my $result = piglat $x
# or in a pipeline:
@list |> map piglat |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pint">
<h3><a class="doc-anchor" href="#doc-pint">#</a> <code>pint</code></h3>
<p><code>pint</code> — extended stdlib builtin. Alias for <code>parse_int</code>.</p>
<pre><code class="lang-perl">my $result = pint $x
# or in a pipeline:
@list |> map pint |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pipe">
<h3><a class="doc-anchor" href="#doc-pipe">#</a> <code>pipe</code></h3>
<p>Create a unidirectional pipe, returning a pair of connected filehandles: one for reading and one for writing. Data written to the write end can be read from the read end, making pipes the fundamental building block for inter-process communication. Commonly used with <code>fork</code> so the parent and child can exchange data.</p>
<pre><code class="lang-perl">pipe(my $rd, my $wr) or die "pipe: $!"
if (fork() == 0) {
close($rd)
print $wr "hello from child\n"
exit(0)
}
close($wr)
my $msg = <$rd>
p $msg # hello from child
</code></pre>
</article>
<article class="doc-entry" id="doc-pipes">
<h3><a class="doc-anchor" href="#doc-pipes">#</a> <code>pipes</code></h3>
<p><code>pipes</code> — filesystem extensions builtin.</p>
<pre><code class="lang-perl">my $result = pipes $x
# or in a pipeline:
@list |> map pipes |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pkc">
<h3><a class="doc-anchor" href="#doc-pkc">#</a> <code>pkc</code></h3>
<p><code>pkc</code> — algebraic match builtin. Alias for <code>peek_clj</code>.</p>
<pre><code class="lang-perl">my $result = pkc $x
# or in a pipeline:
@list |> map pkc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-planck">
<h3><a class="doc-anchor" href="#doc-planck">#</a> <code>planck</code></h3>
<p><code>planck</code> — math / physics constants builtin.</p>
<pre><code class="lang-perl">my $result = planck $x
# or in a pipeline:
@list |> map planck |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-planck-constant">
<h3><a class="doc-anchor" href="#doc-planck-constant">#</a> <code>planck_constant</code></h3>
<p><code>planck_constant</code> — constants builtin.</p>
<pre><code class="lang-perl">my $result = planck_constant $x
# or in a pipeline:
@list |> map planck_constant |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-planck-mass">
<h3><a class="doc-anchor" href="#doc-planck-mass">#</a> <code>planck_mass</code></h3>
<p><code>planck_mass</code> — physics constants builtin.</p>
<pre><code class="lang-perl">my $result = planck_mass $x
# or in a pipeline:
@list |> map planck_mass |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-planck-temperature">
<h3><a class="doc-anchor" href="#doc-planck-temperature">#</a> <code>planck_temperature</code></h3>
<p><code>planck_temperature</code> — physics constants builtin.</p>
<pre><code class="lang-perl">my $result = planck_temperature $x
# or in a pipeline:
@list |> map planck_temperature |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-planck-time">
<h3><a class="doc-anchor" href="#doc-planck-time">#</a> <code>planck_time</code></h3>
<p><code>planck_time</code> — physics constants builtin.</p>
<pre><code class="lang-perl">my $result = planck_time $x
# or in a pipeline:
@list |> map planck_time |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-plastic">
<h3><a class="doc-anchor" href="#doc-plastic">#</a> <code>plastic</code></h3>
<p><code>plastic</code> — math constants builtin. Alias for <code>plastic_number</code>.</p>
<pre><code class="lang-perl">my $result = plastic $x
# or in a pipeline:
@list |> map plastic |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-plastic-number">
<h3><a class="doc-anchor" href="#doc-plastic-number">#</a> <code>plastic_number</code></h3>
<p><code>plastic_number</code> — math constants builtin.</p>
<pre><code class="lang-perl">my $result = plastic_number $x
# or in a pipeline:
@list |> map plastic_number |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-plnorm">
<h3><a class="doc-anchor" href="#doc-plnorm">#</a> <code>plnorm</code></h3>
<p><code>plnorm</code> — log-normal CDF. P(X ≤ x) for LogN(mu, sigma). Args: x, mu, sigma.</p>
<pre><code class="lang-perl">p plnorm(1, 0, 1) # 0.5 (median of LogN(0,1))
</code></pre>
</article>
<article class="doc-entry" id="doc-plur">
<h3><a class="doc-anchor" href="#doc-plur">#</a> <code>plur</code></h3>
<p><code>plur</code> — extended stdlib builtin. Alias for <code>pluralize</code>.</p>
<pre><code class="lang-perl">my $result = plur $x
# or in a pipeline:
@list |> map plur |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pluralize">
<h3><a class="doc-anchor" href="#doc-pluralize">#</a> <code>pluralize</code></h3>
<p><code>pluralize</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = pluralize $x
# or in a pipeline:
@list |> map pluralize |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pmass">
<h3><a class="doc-anchor" href="#doc-pmass">#</a> <code>pmass</code></h3>
<p><code>pmass</code> — constants builtin. Alias for <code>proton_mass</code>.</p>
<pre><code class="lang-perl">my $result = pmass $x
# or in a pipeline:
@list |> map pmass |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pmt">
<h3><a class="doc-anchor" href="#doc-pmt">#</a> <code>pmt</code></h3>
<p><code>pmt($rate, $nper, $pv)</code> — computes the periodic payment for a loan given interest rate, number of periods, and present value. Standard amortization formula.</p>
<pre><code class="lang-perl"># $100k loan, 5% annual rate, 30 years
p pmt(0.05/12, 360, 100000) # ~$537/month
</code></pre>
</article>
<article class="doc-entry" id="doc-pnorm">
<h3><a class="doc-anchor" href="#doc-pnorm">#</a> <code>pnorm</code></h3>
<p><code>pnorm</code> — normal CDF. P(X ≤ x) for N(mu, sigma). Args: x [, mu, sigma]. Default standard normal.</p>
<pre><code class="lang-perl">p pnorm(0) # 0.5
p pnorm(1.96) # 0.975
p pnorm(100, 90, 15) # z-score for IQ 100
</code></pre>
</article>
<article class="doc-entry" id="doc-point-distance">
<h3><a class="doc-anchor" href="#doc-point-distance">#</a> <code>point_distance</code></h3>
<p><code>point_distance</code> — geometry / physics builtin.</p>
<pre><code class="lang-perl">my $result = point_distance $x
# or in a pipeline:
@list |> map point_distance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-point-in-polygon">
<h3><a class="doc-anchor" href="#doc-point-in-polygon">#</a> <code>point_in_polygon</code></h3>
<p><code>point_in_polygon($x, $y, @polygon)</code> (alias <code>pip</code>) — tests if a point lies inside a polygon. Polygon is given as flat list [x1,y1,x2,y2,...]. Returns 1 if inside, 0 if outside. Uses ray-casting algorithm.</p>
<pre><code class="lang-perl">my @square = (0,0, 4,0, 4,4, 0,4)
p pip(2, 2, @square) # 1 (inside)
p pip(5, 5, @square) # 0 (outside)
</code></pre>
</article>
<article class="doc-entry" id="doc-pointer-width">
<h3><a class="doc-anchor" href="#doc-pointer-width">#</a> <code>pointer_width</code></h3>
<p><code>pointer_width</code> — pointer width in bits: <code>32</code> or <code>64</code>. Compile-time constant.</p>
<pre><code class="lang-perl">p pointer_width # 64
</code></pre>
</article>
<article class="doc-entry" id="doc-poisson">
<h3><a class="doc-anchor" href="#doc-poisson">#</a> <code>poisson</code></h3>
<p><code>poisson_pmf($k, $lambda)</code> (alias <code>poisson</code>) — Poisson probability mass function. P(X=k) for events with rate λ.</p>
<pre><code class="lang-perl">p poisson(3, 5) # P(X=3) when avg rate is 5
</code></pre>
</article>
<article class="doc-entry" id="doc-poly-eval">
<h3><a class="doc-anchor" href="#doc-poly-eval">#</a> <code>poly_eval</code></h3>
<p><code>poly_eval</code> (alias <code>polyval</code>) evaluates a polynomial c0 + c1·x + c2·x² + ... using Horner's method.</p>
<pre><code class="lang-perl">p polyval([1, 0, 1], 3) # 1 + 0*3 + 1*9 = 10
</code></pre>
</article>
<article class="doc-entry" id="doc-polyarea">
<h3><a class="doc-anchor" href="#doc-polyarea">#</a> <code>polyarea</code></h3>
<p><code>polyarea</code> — geometry / physics builtin. Alias for <code>polygon_area</code>.</p>
<pre><code class="lang-perl">my $result = polyarea $x
# or in a pipeline:
@list |> map polyarea |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-polyfit">
<h3><a class="doc-anchor" href="#doc-polyfit">#</a> <code>polyfit</code></h3>
<p><code>polynomial_fit</code> (alias <code>polyfit</code>) performs least-squares polynomial fitting. Returns coefficients [c0, c1, ..., cn].</p>
<pre><code class="lang-perl">my $c = polyfit([0,1,2,3], [1,3,5,7], 1) # linear fit
</code></pre>
</article>
<article class="doc-entry" id="doc-polygon-area">
<h3><a class="doc-anchor" href="#doc-polygon-area">#</a> <code>polygon_area</code></h3>
<p><code>polygon_area</code> — geometry / physics builtin.</p>
<pre><code class="lang-perl">my $result = polygon_area $x
# or in a pipeline:
@list |> map polygon_area |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-polygon-perimeter">
<h3><a class="doc-anchor" href="#doc-polygon-perimeter">#</a> <code>polygon_perimeter</code></h3>
<p><code>polygon_perimeter(@points)</code> (alias <code>polyper</code>) — computes the perimeter of a polygon. Points as flat list [x1,y1,x2,y2,...]. Assumes closed polygon.</p>
<pre><code class="lang-perl">my @square = (0,0, 1,0, 1,1, 0,1)
p polyper(@square) # 4
</code></pre>
</article>
<article class="doc-entry" id="doc-polyperim">
<h3><a class="doc-anchor" href="#doc-polyperim">#</a> <code>polyperim</code></h3>
<p><code>polyperim</code> — geometry (extended) builtin. Alias for <code>polygon_perimeter</code>.</p>
<pre><code class="lang-perl">my $result = polyperim $x
# or in a pipeline:
@list |> map polyperim |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pop-clj">
<h3><a class="doc-anchor" href="#doc-pop-clj">#</a> <code>pop_clj</code></h3>
<p><code>pop_clj</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = pop_clj $x
# or in a pipeline:
@list |> map pop_clj |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-popc">
<h3><a class="doc-anchor" href="#doc-popc">#</a> <code>popc</code></h3>
<p><code>popc</code> — algebraic match builtin. Alias for <code>pop_clj</code>.</p>
<pre><code class="lang-perl">my $result = popc $x
# or in a pipeline:
@list |> map popc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-popcount">
<h3><a class="doc-anchor" href="#doc-popcount">#</a> <code>popcount</code></h3>
<p><code>popcount</code> — base conversion builtin. Alias for <code>bits_count</code>.</p>
<pre><code class="lang-perl">my $result = popcount $x
# or in a pipeline:
@list |> map popcount |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pos-n">
<h3><a class="doc-anchor" href="#doc-pos-n">#</a> <code>pos_n</code></h3>
<p><code>pos_n</code> — trivial numeric / predicate builtins builtin. Alias for <code>positive</code>.</p>
<pre><code class="lang-perl">my $result = pos_n $x
# or in a pipeline:
@list |> map pos_n |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-positions-of">
<h3><a class="doc-anchor" href="#doc-positions-of">#</a> <code>positions_of</code></h3>
<p><code>positions_of</code> — collection (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = positions_of $x
# or in a pipeline:
@list |> map positions_of |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-positive">
<h3><a class="doc-anchor" href="#doc-positive">#</a> <code>positive</code></h3>
<p><code>positive</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = positive $x
# or in a pipeline:
@list |> map positive |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-potential-energy">
<h3><a class="doc-anchor" href="#doc-potential-energy">#</a> <code>potential_energy</code></h3>
<p><code>potential_energy</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = potential_energy $x
# or in a pipeline:
@list |> map potential_energy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pow2">
<h3><a class="doc-anchor" href="#doc-pow2">#</a> <code>pow2</code></h3>
<p><code>pow2</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = pow2 $x
# or in a pipeline:
@list |> map pow2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-power-phys">
<h3><a class="doc-anchor" href="#doc-power-phys">#</a> <code>power_phys</code></h3>
<p><code>power_phys</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = power_phys $x
# or in a pipeline:
@list |> map power_phys |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-power-set">
<h3><a class="doc-anchor" href="#doc-power-set">#</a> <code>power_set</code></h3>
<p><code>power_set</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = power_set $x
# or in a pipeline:
@list |> map power_set |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-power-spectrum">
<h3><a class="doc-anchor" href="#doc-power-spectrum">#</a> <code>power_spectrum</code></h3>
<p><code>power_spectrum(\@signal)</code> (alias <code>psd</code>) — computes the power spectral density (magnitude squared of DFT). Returns real values representing power at each frequency bin.</p>
<pre><code class="lang-perl">my $psd = psd(\@signal)
@$psd |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-powers-of-seq">
<h3><a class="doc-anchor" href="#doc-powers-of-seq">#</a> <code>powers_of_seq</code></h3>
<p><code>powers_of_seq</code> — sequences builtin.</p>
<pre><code class="lang-perl">my $result = powers_of_seq $x
# or in a pipeline:
@list |> map powers_of_seq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-powerset">
<h3><a class="doc-anchor" href="#doc-powerset">#</a> <code>powerset</code></h3>
<p><code>powerset</code> — extended stdlib batch 3 builtin. Alias for <code>power_set</code>.</p>
<pre><code class="lang-perl">my $result = powerset $x
# or in a pipeline:
@list |> map powerset |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-powspec">
<h3><a class="doc-anchor" href="#doc-powspec">#</a> <code>powspec</code></h3>
<p><code>powspec</code> — dsp / signal (extended) builtin. Alias for <code>power_spectrum</code>.</p>
<pre><code class="lang-perl">my $result = powspec $x
# or in a pipeline:
@list |> map powspec |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ppi">
<h3><a class="doc-anchor" href="#doc-ppi">#</a> <code>ppi</code></h3>
<p><code>ppi</code> — number theory / primes builtin. Alias for <code>prime_pi</code>.</p>
<pre><code class="lang-perl">my $result = ppi $x
# or in a pipeline:
@list |> map ppi |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ppid">
<h3><a class="doc-anchor" href="#doc-ppid">#</a> <code>ppid</code></h3>
<p><code>ppid</code> — system introspection builtin.</p>
<pre><code class="lang-perl">my $result = ppid $x
# or in a pipeline:
@list |> map ppid |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ppois">
<h3><a class="doc-anchor" href="#doc-ppois">#</a> <code>ppois</code></h3>
<p><code>ppois</code> — Poisson CDF. P(X ≤ k) for Poisson(lambda). Args: k, lambda.</p>
<pre><code class="lang-perl">p ppois(3, 2.5) # P(≤3 events when avg is 2.5)
</code></pre>
</article>
<article class="doc-entry" id="doc-ppt">
<h3><a class="doc-anchor" href="#doc-ppt">#</a> <code>ppt</code></h3>
<p><code>ppt</code> — extended stdlib builtin. Alias for <code>partition_point</code>.</p>
<pre><code class="lang-perl">my $result = ppt $x
# or in a pipeline:
@list |> map ppt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-prect">
<h3><a class="doc-anchor" href="#doc-prect">#</a> <code>prect</code></h3>
<p><code>prect</code> — geometry / physics builtin. Alias for <code>perimeter_rectangle</code>.</p>
<pre><code class="lang-perl">my $result = prect $x
# or in a pipeline:
@list |> map prect |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pred">
<h3><a class="doc-anchor" href="#doc-pred">#</a> <code>pred</code></h3>
<p><code>pred</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = pred $x
# or in a pipeline:
@list |> map pred |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-predict">
<h3><a class="doc-anchor" href="#doc-predict">#</a> <code>predict</code></h3>
<p><code>predict_lm</code> (alias <code>predict</code>) — predict from a linear model at new x values.</p>
<pre><code class="lang-perl">my $model = lm([1,2,3], [2,4,6])
my @pred = @{predict($model, [4,5,6])} # [8,10,12]
</code></pre>
</article>
<article class="doc-entry" id="doc-prefix-sums">
<h3><a class="doc-anchor" href="#doc-prefix-sums">#</a> <code>prefix_sums</code></h3>
<p><code>prefix_sums</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = prefix_sums $x
# or in a pipeline:
@list |> map prefix_sums |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-prepend">
<h3><a class="doc-anchor" href="#doc-prepend">#</a> <code>prepend</code></h3>
<p><code>prepend</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = prepend $x
# or in a pipeline:
@list |> map prepend |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-present-value">
<h3><a class="doc-anchor" href="#doc-present-value">#</a> <code>present_value</code></h3>
<p><code>present_value</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = present_value $x
# or in a pipeline:
@list |> map present_value |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-prev-prime">
<h3><a class="doc-anchor" href="#doc-prev-prime">#</a> <code>prev_prime</code></h3>
<p><code>prev_prime</code> — number theory / primes builtin.</p>
<pre><code class="lang-perl">my $result = prev_prime $x
# or in a pipeline:
@list |> map prev_prime |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-prime-factors">
<h3><a class="doc-anchor" href="#doc-prime-factors">#</a> <code>prime_factors</code></h3>
<p><code>prime_factors</code> — number theory / primes builtin.</p>
<pre><code class="lang-perl">my $result = prime_factors $x
# or in a pipeline:
@list |> map prime_factors |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-prime-pi">
<h3><a class="doc-anchor" href="#doc-prime-pi">#</a> <code>prime_pi</code></h3>
<p><code>prime_pi</code> — number theory / primes builtin.</p>
<pre><code class="lang-perl">my $result = prime_pi $x
# or in a pipeline:
@list |> map prime_pi |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-primes-seq">
<h3><a class="doc-anchor" href="#doc-primes-seq">#</a> <code>primes_seq</code></h3>
<p><code>primes_seq</code> — sequences builtin.</p>
<pre><code class="lang-perl">my $result = primes_seq $x
# or in a pipeline:
@list |> map primes_seq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-primes-up-to">
<h3><a class="doc-anchor" href="#doc-primes-up-to">#</a> <code>primes_up_to</code></h3>
<p><code>primes_up_to</code> — number theory / primes builtin.</p>
<pre><code class="lang-perl">my $result = primes_up_to $x
# or in a pipeline:
@list |> map primes_up_to |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-proc-mem">
<h3><a class="doc-anchor" href="#doc-proc-mem">#</a> <code>proc_mem</code></h3>
<p><code>proc_mem</code> (alias <code>rss</code>) — current process resident set size (RSS) in bytes. On Linux reads <code>VmRSS</code> from <code>/proc/self/status</code>. On macOS uses <code>getrusage(RUSAGE_SELF)</code>. Returns <code>undef</code> on unsupported platforms.</p>
<pre><code class="lang-perl">p format_bytes(rss) # 18.5 MiB
my $before = rss
do_work()
p format_bytes(rss - $before) . " allocated"
</code></pre>
</article>
<article class="doc-entry" id="doc-product-list">
<h3><a class="doc-anchor" href="#doc-product-list">#</a> <code>product_list</code></h3>
<p><code>product_list</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = product_list $x
# or in a pipeline:
@list |> map product_list |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-product-of">
<h3><a class="doc-anchor" href="#doc-product-of">#</a> <code>product_of</code></h3>
<p><code>product_of</code> — more list helpers builtin.</p>
<pre><code class="lang-perl">my $result = product_of $x
# or in a pipeline:
@list |> map product_of |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-projectile-max-height">
<h3><a class="doc-anchor" href="#doc-projectile-max-height">#</a> <code>projectile_max_height</code></h3>
<p><code>projectile_max_height($velocity, $angle)</code> (alias <code>projheight</code>) — maximum height H = v²sin²(θ)/(2g).</p>
<pre><code class="lang-perl">p projheight(100, 45) # ~255 m
p projheight(100, 90) # ~510 m (straight up)
</code></pre>
</article>
<article class="doc-entry" id="doc-projectile-range">
<h3><a class="doc-anchor" href="#doc-projectile-range">#</a> <code>projectile_range</code></h3>
<p><code>projectile_range($velocity, $angle)</code> (alias <code>projrange</code>) — horizontal range R = v²sin(2θ)/g. Angle in degrees.</p>
<pre><code class="lang-perl">p projrange(100, 45) # ~1020 m (optimal angle for range)
p projrange(100, 30) # ~884 m
</code></pre>
</article>
<article class="doc-entry" id="doc-projectile-time">
<h3><a class="doc-anchor" href="#doc-projectile-time">#</a> <code>projectile_time</code></h3>
<p><code>projectile_time</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = projectile_time $x
# or in a pipeline:
@list |> map projectile_time |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-projtime">
<h3><a class="doc-anchor" href="#doc-projtime">#</a> <code>projtime</code></h3>
<p><code>projtime</code> — physics formulas builtin. Alias for <code>projectile_time</code>.</p>
<pre><code class="lang-perl">my $result = projtime $x
# or in a pipeline:
@list |> map projtime |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-prop-table">
<h3><a class="doc-anchor" href="#doc-prop-table">#</a> <code>prop_table</code></h3>
<p><code>prop_table</code> — convert a count matrix to proportions (each cell / total). Like R's prop.table().</p>
<pre><code class="lang-perl">p prop_table([[10,20],[30,40]]) # [[0.1,0.2],[0.3,0.4]]
</code></pre>
</article>
<article class="doc-entry" id="doc-prop-test">
<h3><a class="doc-anchor" href="#doc-prop-test">#</a> <code>prop_test</code></h3>
<p><code>prop_test</code> — one-sample proportion z-test. Returns [z-statistic, p-value]. Like R's prop.test().</p>
<pre><code class="lang-perl">my ($z, $pval) = @{proptest(55, 100, 0.5)} # test if 55/100 differs from 50%%
</code></pre>
</article>
<article class="doc-entry" id="doc-proton-mass">
<h3><a class="doc-anchor" href="#doc-proton-mass">#</a> <code>proton_mass</code></h3>
<p><code>proton_mass</code> — constants builtin.</p>
<pre><code class="lang-perl">my $result = proton_mass $x
# or in a pipeline:
@list |> map proton_mass |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-prvp">
<h3><a class="doc-anchor" href="#doc-prvp">#</a> <code>prvp</code></h3>
<p><code>prvp</code> — number theory / primes builtin. Alias for <code>prev_prime</code>.</p>
<pre><code class="lang-perl">my $result = prvp $x
# or in a pipeline:
@list |> map prvp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-psi-to-pascals">
<h3><a class="doc-anchor" href="#doc-psi-to-pascals">#</a> <code>psi_to_pascals</code></h3>
<p><code>psi_to_pascals</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = psi_to_pascals $input
</code></pre>
</article>
<article class="doc-entry" id="doc-pt">
<h3><a class="doc-anchor" href="#doc-pt">#</a> <code>pt</code></h3>
<p><code>pt</code> — Student's t CDF. Args: x, df.</p>
<pre><code class="lang-perl">p pt(1.96, 100) # ≈ 0.975
</code></pre>
</article>
<article class="doc-entry" id="doc-ptdist">
<h3><a class="doc-anchor" href="#doc-ptdist">#</a> <code>ptdist</code></h3>
<p><code>ptdist</code> — geometry / physics builtin. Alias for <code>point_distance</code>.</p>
<pre><code class="lang-perl">my $result = ptdist $x
# or in a pipeline:
@list |> map ptdist |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ptinpoly">
<h3><a class="doc-anchor" href="#doc-ptinpoly">#</a> <code>ptinpoly</code></h3>
<p><code>ptinpoly</code> — geometry (extended) builtin. Alias for <code>point_in_polygon</code>.</p>
<pre><code class="lang-perl">my $result = ptinpoly $x
# or in a pipeline:
@list |> map ptinpoly |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ptri">
<h3><a class="doc-anchor" href="#doc-ptri">#</a> <code>ptri</code></h3>
<p><code>ptri</code> — geometry / physics builtin. Alias for <code>perimeter_triangle</code>.</p>
<pre><code class="lang-perl">my $result = ptri $x
# or in a pipeline:
@list |> map ptri |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-punct">
<h3><a class="doc-anchor" href="#doc-punct">#</a> <code>punct</code></h3>
<p><code>punctuation</code> (alias <code>punct</code>) extracts all ASCII punctuation characters from a string and returns them as a list. Filters out letters, digits, whitespace — keeps only punctuation.</p>
<pre><code class="lang-perl">p join "", punctuation("Hello, world!") # ,!
"a.b-c" |> punct |> cnt |> p # 2
</code></pre>
</article>
<article class="doc-entry" id="doc-punif">
<h3><a class="doc-anchor" href="#doc-punif">#</a> <code>punif</code></h3>
<p><code>punif</code> — uniform CDF. P(X ≤ x) for Uniform(a, b). Args: x, a, b.</p>
<pre><code class="lang-perl">p punif(0.5, 0, 1) # 0.5
p punif(3, 0, 10) # 0.3
</code></pre>
</article>
<article class="doc-entry" id="doc-purple">
<h3><a class="doc-anchor" href="#doc-purple">#</a> <code>purple</code></h3>
<p><code>purple</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = purple $x
# or in a pipeline:
@list |> map purple |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pv">
<h3><a class="doc-anchor" href="#doc-pv">#</a> <code>pv</code></h3>
<p><code>pv</code> — finance (extended) builtin.</p>
<pre><code class="lang-perl">my $result = pv $x
# or in a pipeline:
@list |> map pv |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pwd-str">
<h3><a class="doc-anchor" href="#doc-pwd-str">#</a> <code>pwd_str</code></h3>
<p><code>pwd_str</code> — more process / system builtin. Alias for <code>cwd</code>.</p>
<pre><code class="lang-perl">my $result = pwd_str $x
# or in a pipeline:
@list |> map pwd_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pweibull">
<h3><a class="doc-anchor" href="#doc-pweibull">#</a> <code>pweibull</code></h3>
<p><code>pweibull</code> — Weibull CDF. P(X ≤ x) for Weibull(shape, scale). Args: x, shape, scale.</p>
<pre><code class="lang-perl">p pweibull(1, 1, 1) # same as exponential
</code></pre>
</article>
<article class="doc-entry" id="doc-pwi">
<h3><a class="doc-anchor" href="#doc-pwi">#</a> <code>pwi</code></h3>
<p><code>pwi</code> — python/ruby stdlib builtin. Alias for <code>pairwise_iter</code>.</p>
<pre><code class="lang-perl">my $result = pwi $x
# or in a pipeline:
@list |> map pwi |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-pyramid-volume">
<h3><a class="doc-anchor" href="#doc-pyramid-volume">#</a> <code>pyramid_volume</code></h3>
<p><code>pyramid_volume($base_area, $height)</code> — computes the volume of a pyramid. Returns <code>(1/3) * base_area * height</code>.</p>
<pre><code class="lang-perl">p pyramid_volume(100, 15) # 500
</code></pre>
</article>
<article class="doc-entry" id="doc-pyrvol">
<h3><a class="doc-anchor" href="#doc-pyrvol">#</a> <code>pyrvol</code></h3>
<p><code>pyrvol</code> — geometry (extended) builtin. Alias for <code>pyramid_volume</code>.</p>
<pre><code class="lang-perl">my $result = pyrvol $x
# or in a pipeline:
@list |> map pyrvol |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-q">
<h3><a class="doc-anchor" href="#doc-q">#</a> <code>q</code></h3>
<p><code>q</code> — quoting builtin.</p>
<pre><code class="lang-perl">my $result = q $x
# or in a pipeline:
@list |> map q |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-qbeta">
<h3><a class="doc-anchor" href="#doc-qbeta">#</a> <code>qbeta</code></h3>
<p><code>qbeta</code> — beta quantile. Args: p, alpha, beta.</p>
<pre><code class="lang-perl">p qbeta(0.5, 2, 5) # median of Beta(2,5)
</code></pre>
</article>
<article class="doc-entry" id="doc-qbinom">
<h3><a class="doc-anchor" href="#doc-qbinom">#</a> <code>qbinom</code></h3>
<p><code>qbinom</code> — binomial quantile (smallest k where P(X≤k) ≥ p). Args: p, n, prob.</p>
<pre><code class="lang-perl">p qbinom(0.5, 10, 0.5) # median of Binom(10, 0.5) = 5
</code></pre>
</article>
<article class="doc-entry" id="doc-qcauchy">
<h3><a class="doc-anchor" href="#doc-qcauchy">#</a> <code>qcauchy</code></h3>
<p><code>qcauchy</code> — Cauchy quantile. Args: p [, location, scale].</p>
<pre><code class="lang-perl">p qcauchy(0.75, 0, 1) # 1.0
</code></pre>
</article>
<article class="doc-entry" id="doc-qchisq">
<h3><a class="doc-anchor" href="#doc-qchisq">#</a> <code>qchisq</code></h3>
<p><code>qchisq</code> — chi-squared quantile. Args: p, df.</p>
<pre><code class="lang-perl">p qchisq(0.95, 1) # 3.84 (critical value)
p qchisq(0.95, 5) # 11.07
</code></pre>
</article>
<article class="doc-entry" id="doc-qdisc">
<h3><a class="doc-anchor" href="#doc-qdisc">#</a> <code>qdisc</code></h3>
<p><code>quadratic_discriminant($a, $b, $c)</code> (alias <code>qdisc</code>) — computes b² - 4ac. Positive = two real roots, zero = one repeated root, negative = complex roots.</p>
<pre><code class="lang-perl">p qdisc(1, -5, 6) # 1 (two distinct real roots)
p qdisc(1, 2, 1) # 0 (one repeated root)
p qdisc(1, 2, 5) # -16 (complex roots)
</code></pre>
</article>
<article class="doc-entry" id="doc-qexp">
<h3><a class="doc-anchor" href="#doc-qexp">#</a> <code>qexp</code></h3>
<p><code>qexp</code> — exponential quantile. Args: p [, rate].</p>
<pre><code class="lang-perl">p qexp(0.5, 1) # 0.693 (median of Exp(1))
</code></pre>
</article>
<article class="doc-entry" id="doc-qf">
<h3><a class="doc-anchor" href="#doc-qf">#</a> <code>qf</code></h3>
<p><code>qf</code> — F-distribution quantile. Args: p, d1, d2.</p>
<pre><code class="lang-perl">p qf(0.95, 5, 10) # critical F value
</code></pre>
</article>
<article class="doc-entry" id="doc-qgamma">
<h3><a class="doc-anchor" href="#doc-qgamma">#</a> <code>qgamma</code></h3>
<p><code>qgamma</code> — gamma quantile (inverse CDF). Args: p, shape [, scale].</p>
<pre><code class="lang-perl">p qgamma(0.95, 2, 1) # 95th percentile of Gamma(2,1)
</code></pre>
</article>
<article class="doc-entry" id="doc-qlnorm">
<h3><a class="doc-anchor" href="#doc-qlnorm">#</a> <code>qlnorm</code></h3>
<p><code>qlnorm</code> — log-normal quantile. Args: p [, mu, sigma].</p>
<pre><code class="lang-perl">p qlnorm(0.5, 0, 1) # 1.0 (median of LogN(0,1))
</code></pre>
</article>
<article class="doc-entry" id="doc-qm">
<h3><a class="doc-anchor" href="#doc-qm">#</a> <code>qm</code></h3>
<p><code>qm</code> — string builtin. Alias for <code>quotemeta</code>.</p>
<pre><code class="lang-perl">my $result = qm $x
# or in a pipeline:
@list |> map qm |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-qnorm">
<h3><a class="doc-anchor" href="#doc-qnorm">#</a> <code>qnorm</code></h3>
<p><code>qnorm</code> — normal quantile (inverse CDF). Returns x such that P(X ≤ x) = p. Args: p [, mu, sigma].</p>
<pre><code class="lang-perl">p qnorm(0.975) # 1.96
p qnorm(0.5) # 0.0
p qnorm(0.95, 100, 15) # 90th percentile IQ
</code></pre>
</article>
<article class="doc-entry" id="doc-qntl">
<h3><a class="doc-anchor" href="#doc-qntl">#</a> <code>qntl</code></h3>
<p><code>qntl</code> — extended stdlib builtin. Alias for <code>quantile</code>.</p>
<pre><code class="lang-perl">my $result = qntl $x
# or in a pipeline:
@list |> map qntl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-qpois">
<h3><a class="doc-anchor" href="#doc-qpois">#</a> <code>qpois</code></h3>
<p><code>qpois</code> — Poisson quantile (smallest k where P(X≤k) ≥ p). Args: p, lambda.</p>
<pre><code class="lang-perl">p qpois(0.5, 5) # median of Poisson(5)
</code></pre>
</article>
<article class="doc-entry" id="doc-qq">
<h3><a class="doc-anchor" href="#doc-qq">#</a> <code>qq</code></h3>
<p><code>qq</code> — quoting builtin.</p>
<pre><code class="lang-perl">my $result = qq $x
# or in a pipeline:
@list |> map qq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-qroots">
<h3><a class="doc-anchor" href="#doc-qroots">#</a> <code>qroots</code></h3>
<p><code>quadratic_roots($a, $b, $c)</code> (alias <code>qroots</code>) — solves ax² + bx + c = 0. Returns [x1, x2] for real roots, undef if no real solutions (discriminant < 0).</p>
<pre><code class="lang-perl">my @roots = quadratic_roots(1, -5, 6) # [3, 2] (x² - 5x + 6 = 0)
p qroots(1, 0, -4) # [2, -2]
p qroots(1, 2, 5) # undef (complex roots)
</code></pre>
</article>
<article class="doc-entry" id="doc-qt">
<h3><a class="doc-anchor" href="#doc-qt">#</a> <code>qt</code></h3>
<p><code>qt</code> — Student's t quantile. Args: p, df.</p>
<pre><code class="lang-perl">p qt(0.975, 10) # ≈ 2.228 (two-tailed 5%)
</code></pre>
</article>
<article class="doc-entry" id="doc-quantile">
<h3><a class="doc-anchor" href="#doc-quantile">#</a> <code>quantile</code></h3>
<p><code>quantile</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = quantile $x
# or in a pipeline:
@list |> map quantile |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-quarter-of">
<h3><a class="doc-anchor" href="#doc-quarter-of">#</a> <code>quarter_of</code></h3>
<p><code>quarter_of</code> — date helpers builtin.</p>
<pre><code class="lang-perl">my $result = quarter_of $x
# or in a pipeline:
@list |> map quarter_of |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-quartiles">
<h3><a class="doc-anchor" href="#doc-quartiles">#</a> <code>quartiles</code></h3>
<p><code>quartiles(@data)</code> — returns the three quartile values [Q1, Q2, Q3] of a dataset. Q1 is the 25th percentile, Q2 is the median (50th), Q3 is the 75th percentile. Useful for understanding data distribution and computing IQR.</p>
<pre><code class="lang-perl">my @data = 1..100
my $q = quartiles(@data)
p "Q1=$q->[0] Q2=$q->[1] Q3=$q->[2]"
</code></pre>
</article>
<article class="doc-entry" id="doc-quarts">
<h3><a class="doc-anchor" href="#doc-quarts">#</a> <code>quarts</code></h3>
<p><code>quarts</code> — statistics (extended) builtin. Alias for <code>quartiles</code>.</p>
<pre><code class="lang-perl">my $result = quarts $x
# or in a pipeline:
@list |> map quarts |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-queue-new">
<h3><a class="doc-anchor" href="#doc-queue-new">#</a> <code>queue_new</code></h3>
<p><code>queue_new</code> — data structure helpers builtin.</p>
<pre><code class="lang-perl">my $result = queue_new $x
# or in a pipeline:
@list |> map queue_new |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-qunif">
<h3><a class="doc-anchor" href="#doc-qunif">#</a> <code>qunif</code></h3>
<p><code>qunif</code> — uniform quantile. Args: p [, min, max].</p>
<pre><code class="lang-perl">p qunif(0.5, 0, 10) # 5.0 (median)
</code></pre>
</article>
<article class="doc-entry" id="doc-quote">
<h3><a class="doc-anchor" href="#doc-quote">#</a> <code>quote</code></h3>
<p><code>quote</code> — string quote / escape builtin.</p>
<pre><code class="lang-perl">my $result = quote $x
# or in a pipeline:
@list |> map quote |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-qw">
<h3><a class="doc-anchor" href="#doc-qw">#</a> <code>qw</code></h3>
<p><code>qw</code> — quoting builtin.</p>
<pre><code class="lang-perl">my $result = qw $x
# or in a pipeline:
@list |> map qw |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-qweibull">
<h3><a class="doc-anchor" href="#doc-qweibull">#</a> <code>qweibull</code></h3>
<p><code>qweibull</code> — Weibull quantile. Args: p, shape [, scale].</p>
<pre><code class="lang-perl">p qweibull(0.5, 1, 1) # same as qexp
</code></pre>
</article>
<article class="doc-entry" id="doc-r2d">
<h3><a class="doc-anchor" href="#doc-r2d">#</a> <code>r2d</code></h3>
<p><code>r2d</code> — trivial numeric / predicate builtins builtin. Alias for <code>rad_to_deg</code>.</p>
<pre><code class="lang-perl">my $result = r2d $x
# or in a pipeline:
@list |> map r2d |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-r72">
<h3><a class="doc-anchor" href="#doc-r72">#</a> <code>r72</code></h3>
<p><code>rule_of_72($rate)</code> (alias <code>r72</code>) — estimates years to double investment using the Rule of 72: 72 / (rate × 100). Quick mental math approximation.</p>
<pre><code class="lang-perl">p r72(0.06) # 12 years to double at 6%
p r72(0.10) # 7.2 years at 10%
</code></pre>
</article>
<article class="doc-entry" id="doc-r-squared">
<h3><a class="doc-anchor" href="#doc-r-squared">#</a> <code>r_squared</code></h3>
<p><code>r_squared</code> — math functions builtin.</p>
<pre><code class="lang-perl">my $result = r_squared $x
# or in a pipeline:
@list |> map r_squared |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rad-to-deg">
<h3><a class="doc-anchor" href="#doc-rad-to-deg">#</a> <code>rad_to_deg</code></h3>
<p><code>rad_to_deg</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = rad_to_deg $input
</code></pre>
</article>
<article class="doc-entry" id="doc-radd">
<h3><a class="doc-anchor" href="#doc-radd">#</a> <code>radd</code></h3>
<p><code>radd</code> — roman numerals builtin. Alias for <code>roman_add</code>.</p>
<pre><code class="lang-perl">my $result = radd $x
# or in a pipeline:
@list |> map radd |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-radians">
<h3><a class="doc-anchor" href="#doc-radians">#</a> <code>radians</code></h3>
<p><code>radians</code> — trig / math (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = radians $x
# or in a pipeline:
@list |> map radians |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-random-alpha">
<h3><a class="doc-anchor" href="#doc-random-alpha">#</a> <code>random_alpha</code></h3>
<p><code>random_alpha</code> — random builtin.</p>
<pre><code class="lang-perl">my $result = random_alpha $x
# or in a pipeline:
@list |> map random_alpha |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-random-between">
<h3><a class="doc-anchor" href="#doc-random-between">#</a> <code>random_between</code></h3>
<p><code>random_between</code> — random builtin.</p>
<pre><code class="lang-perl">my $result = random_between $x
# or in a pipeline:
@list |> map random_between |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-random-bool">
<h3><a class="doc-anchor" href="#doc-random-bool">#</a> <code>random_bool</code></h3>
<p><code>random_bool</code> — random builtin.</p>
<pre><code class="lang-perl">my $result = random_bool $x
# or in a pipeline:
@list |> map random_bool |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-random-char">
<h3><a class="doc-anchor" href="#doc-random-char">#</a> <code>random_char</code></h3>
<p><code>random_char</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = random_char $x
# or in a pipeline:
@list |> map random_char |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-random-choice">
<h3><a class="doc-anchor" href="#doc-random-choice">#</a> <code>random_choice</code></h3>
<p><code>random_choice</code> — random builtin.</p>
<pre><code class="lang-perl">my $result = random_choice $x
# or in a pipeline:
@list |> map random_choice |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-random-color">
<h3><a class="doc-anchor" href="#doc-random-color">#</a> <code>random_color</code></h3>
<p><code>random_color</code> — color operations builtin.</p>
<pre><code class="lang-perl">my $result = random_color $x
# or in a pipeline:
@list |> map random_color |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-random-digit">
<h3><a class="doc-anchor" href="#doc-random-digit">#</a> <code>random_digit</code></h3>
<p><code>random_digit</code> — random builtin.</p>
<pre><code class="lang-perl">my $result = random_digit $x
# or in a pipeline:
@list |> map random_digit |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-random-float">
<h3><a class="doc-anchor" href="#doc-random-float">#</a> <code>random_float</code></h3>
<p><code>random_float</code> — random builtin.</p>
<pre><code class="lang-perl">my $result = random_float $x
# or in a pipeline:
@list |> map random_float |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-random-int">
<h3><a class="doc-anchor" href="#doc-random-int">#</a> <code>random_int</code></h3>
<p><code>random_int</code> — random builtin.</p>
<pre><code class="lang-perl">my $result = random_int $x
# or in a pipeline:
@list |> map random_int |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-random-sample">
<h3><a class="doc-anchor" href="#doc-random-sample">#</a> <code>random_sample</code></h3>
<p><code>random_sample</code> — collection (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = random_sample $x
# or in a pipeline:
@list |> map random_sample |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-random-string">
<h3><a class="doc-anchor" href="#doc-random-string">#</a> <code>random_string</code></h3>
<p><code>random_string</code> — random builtin.</p>
<pre><code class="lang-perl">my $result = random_string $x
# or in a pipeline:
@list |> map random_string |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-range-compress">
<h3><a class="doc-anchor" href="#doc-range-compress">#</a> <code>range_compress</code></h3>
<p><code>range_compress</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = range_compress $x
# or in a pipeline:
@list |> map range_compress |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-range-exclusive">
<h3><a class="doc-anchor" href="#doc-range-exclusive">#</a> <code>range_exclusive</code></h3>
<p><code>range_exclusive</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = range_exclusive $x
# or in a pipeline:
@list |> map range_exclusive |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-range-expand">
<h3><a class="doc-anchor" href="#doc-range-expand">#</a> <code>range_expand</code></h3>
<p><code>range_expand</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = range_expand $x
# or in a pipeline:
@list |> map range_expand |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-range-inclusive">
<h3><a class="doc-anchor" href="#doc-range-inclusive">#</a> <code>range_inclusive</code></h3>
<p><code>range_inclusive</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = range_inclusive $x
# or in a pipeline:
@list |> map range_inclusive |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-range-of">
<h3><a class="doc-anchor" href="#doc-range-of">#</a> <code>range_of</code></h3>
<p><code>range_of</code> — more list helpers builtin.</p>
<pre><code class="lang-perl">my $result = range_of $x
# or in a pipeline:
@list |> map range_of |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rank">
<h3><a class="doc-anchor" href="#doc-rank">#</a> <code>rank</code></h3>
<p><code>rank</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = rank $x
# or in a pipeline:
@list |> map rank |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rapid-blink">
<h3><a class="doc-anchor" href="#doc-rapid-blink">#</a> <code>rapid_blink</code></h3>
<p><code>rapid_blink</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = rapid_blink $x
# or in a pipeline:
@list |> map rapid_blink |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rb">
<h3><a class="doc-anchor" href="#doc-rb">#</a> <code>rb</code></h3>
<p><code>rb</code> — filesystem extensions builtin. Alias for <code>read_bytes</code>.</p>
<pre><code class="lang-perl">my $result = rb $x
# or in a pipeline:
@list |> map rb |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rbeta">
<h3><a class="doc-anchor" href="#doc-rbeta">#</a> <code>rbeta</code></h3>
<p><code>rbeta</code> — generate n random beta variates. Args: n, alpha, beta. Like R's rbeta().</p>
<pre><code class="lang-perl">my @x = @{rbeta(100, 2, 5)} # Beta(2,5)
</code></pre>
</article>
<article class="doc-entry" id="doc-rbind">
<h3><a class="doc-anchor" href="#doc-rbind">#</a> <code>rbind</code></h3>
<p><code>rbind</code> — bind matrices/vectors by rows (vertical stack). Like R's rbind().</p>
<pre><code class="lang-perl">my $m = rbind([1,2,3], [4,5,6]) # [[1,2,3],[4,5,6]]
</code></pre>
</article>
<article class="doc-entry" id="doc-rbinom">
<h3><a class="doc-anchor" href="#doc-rbinom">#</a> <code>rbinom</code></h3>
<p><code>rbinom</code> — generate n random binomial variates. Args: n, size, prob. Like R's rbinom().</p>
<pre><code class="lang-perl">my @x = @{rbinom(100, 10, 0.3)} # 100 draws from Binom(10,0.3)
</code></pre>
</article>
<article class="doc-entry" id="doc-rc-time-constant">
<h3><a class="doc-anchor" href="#doc-rc-time-constant">#</a> <code>rc_time_constant</code></h3>
<p><code>rc_time_constant</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = rc_time_constant $x
# or in a pipeline:
@list |> map rc_time_constant |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rcauchy">
<h3><a class="doc-anchor" href="#doc-rcauchy">#</a> <code>rcauchy</code></h3>
<p><code>rcauchy</code> — generate n random Cauchy variates. Args: n [, location, scale].</p>
<pre><code class="lang-perl">my @x = @{rcauchy(100, 0, 1)} # standard Cauchy
</code></pre>
</article>
<article class="doc-entry" id="doc-rchisq">
<h3><a class="doc-anchor" href="#doc-rchisq">#</a> <code>rchisq</code></h3>
<p><code>rchisq</code> — generate n random chi-squared variates. Args: n, df. Like R's rchisq().</p>
<pre><code class="lang-perl">my @x = @{rchisq(100, 5)} # Chi-sq with 5 df
</code></pre>
</article>
<article class="doc-entry" id="doc-rcolor">
<h3><a class="doc-anchor" href="#doc-rcolor">#</a> <code>rcolor</code></h3>
<p><code>rcolor</code> — color operations builtin. Alias for <code>random_color</code>.</p>
<pre><code class="lang-perl">my $result = rcolor $x
# or in a pipeline:
@list |> map rcolor |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rctau">
<h3><a class="doc-anchor" href="#doc-rctau">#</a> <code>rctau</code></h3>
<p><code>rctau</code> — physics formulas builtin. Alias for <code>rc_time_constant</code>.</p>
<pre><code class="lang-perl">my $result = rctau $x
# or in a pipeline:
@list |> map rctau |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rdcs">
<h3><a class="doc-anchor" href="#doc-rdcs">#</a> <code>rdcs</code></h3>
<p><code>rdcs</code> — algebraic match builtin. Alias for <code>reductions</code>.</p>
<pre><code class="lang-perl">my $result = rdcs $x
# or in a pipeline:
@list |> map rdcs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-re-escape">
<h3><a class="doc-anchor" href="#doc-re-escape">#</a> <code>re_escape</code></h3>
<p><code>re_escape</code> — more regex builtin.</p>
<pre><code class="lang-perl">my $result = re_escape $x
# or in a pipeline:
@list |> map re_escape |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-re-find-all">
<h3><a class="doc-anchor" href="#doc-re-find-all">#</a> <code>re_find_all</code></h3>
<p><code>re_find_all</code> — more regex builtin.</p>
<pre><code class="lang-perl">my $result = re_find_all $x
# or in a pipeline:
@list |> map re_find_all |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-re-groups">
<h3><a class="doc-anchor" href="#doc-re-groups">#</a> <code>re_groups</code></h3>
<p><code>re_groups</code> — more regex builtin.</p>
<pre><code class="lang-perl">my $result = re_groups $x
# or in a pipeline:
@list |> map re_groups |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-re-match">
<h3><a class="doc-anchor" href="#doc-re-match">#</a> <code>re_match</code></h3>
<p><code>re_match</code> — file stat / path builtin. Alias for <code>matches_regex</code>.</p>
<pre><code class="lang-perl">my $result = re_match $x
# or in a pipeline:
@list |> map re_match |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-re-split-limit">
<h3><a class="doc-anchor" href="#doc-re-split-limit">#</a> <code>re_split_limit</code></h3>
<p><code>re_split_limit</code> — more regex builtin.</p>
<pre><code class="lang-perl">my $result = re_split_limit $x
# or in a pipeline:
@list |> map re_split_limit |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-re-test">
<h3><a class="doc-anchor" href="#doc-re-test">#</a> <code>re_test</code></h3>
<p><code>re_test</code> — more regex builtin.</p>
<pre><code class="lang-perl">my $result = re_test $x
# or in a pipeline:
@list |> map re_test |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rearth">
<h3><a class="doc-anchor" href="#doc-rearth">#</a> <code>rearth</code></h3>
<p><code>rearth</code> — physics constants builtin. Alias for <code>earth_radius</code>.</p>
<pre><code class="lang-perl">my $result = rearth $x
# or in a pipeline:
@list |> map rearth |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-recip">
<h3><a class="doc-anchor" href="#doc-recip">#</a> <code>recip</code></h3>
<p><code>recip</code> — extended stdlib builtin. Alias for <code>reciprocal_of</code>.</p>
<pre><code class="lang-perl">my $result = recip $x
# or in a pipeline:
@list |> map recip |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-reciprocal">
<h3><a class="doc-anchor" href="#doc-reciprocal">#</a> <code>reciprocal</code></h3>
<p><code>reciprocal</code> — math functions builtin.</p>
<pre><code class="lang-perl">my $result = reciprocal $x
# or in a pipeline:
@list |> map reciprocal |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-reciprocal-of">
<h3><a class="doc-anchor" href="#doc-reciprocal-of">#</a> <code>reciprocal_of</code></h3>
<p><code>reciprocal_of</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = reciprocal_of $x
# or in a pipeline:
@list |> map reciprocal_of |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-red">
<h3><a class="doc-anchor" href="#doc-red">#</a> <code>red</code></h3>
<p><code>red</code> — color / ansi builtin.</p>
<pre><code class="lang-perl">my $result = red $x
# or in a pipeline:
@list |> map red |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-red-bold">
<h3><a class="doc-anchor" href="#doc-red-bold">#</a> <code>red_bold</code></h3>
<p><code>red_bold</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = red_bold $x
# or in a pipeline:
@list |> map red_bold |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-redi">
<h3><a class="doc-anchor" href="#doc-redi">#</a> <code>redi</code></h3>
<p><code>redi</code> — go/general functional utilities builtin. Alias for <code>reduce_indexed</code>.</p>
<pre><code class="lang-perl">my $result = redi $x
# or in a pipeline:
@list |> map redi |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-redr">
<h3><a class="doc-anchor" href="#doc-redr">#</a> <code>redr</code></h3>
<p><code>redr</code> — additional missing stdlib functions builtin. Alias for <code>reduce_right</code>.</p>
<pre><code class="lang-perl">my $result = redr $x
# or in a pipeline:
@list |> map redr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-reduce-indexed">
<h3><a class="doc-anchor" href="#doc-reduce-indexed">#</a> <code>reduce_indexed</code></h3>
<p><code>reduce_indexed</code> — go/general functional utilities builtin.</p>
<pre><code class="lang-perl">my $result = reduce_indexed $x
# or in a pipeline:
@list |> map reduce_indexed |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-reduce-right">
<h3><a class="doc-anchor" href="#doc-reduce-right">#</a> <code>reduce_right</code></h3>
<p><code>reduce_right</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = reduce_right $x
# or in a pipeline:
@list |> map reduce_right |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-reflect-point">
<h3><a class="doc-anchor" href="#doc-reflect-point">#</a> <code>reflect_point</code></h3>
<p><code>reflect_point($x, $y, $axis)</code> — reflects a point across an axis. Axis can be 'x', 'y', or 'origin'. Returns the reflected coordinates.</p>
<pre><code class="lang-perl">p reflect_point(3, 4, 'x') # [3, -4]
p reflect_point(3, 4, 'y') # [-3, 4]
p reflect_point(3, 4, 'origin') # [-3, -4]
</code></pre>
</article>
<article class="doc-entry" id="doc-reflpt">
<h3><a class="doc-anchor" href="#doc-reflpt">#</a> <code>reflpt</code></h3>
<p><code>reflpt</code> — geometry (extended) builtin. Alias for <code>reflect_point</code>.</p>
<pre><code class="lang-perl">my $result = reflpt $x
# or in a pipeline:
@list |> map reflpt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-regex-extract">
<h3><a class="doc-anchor" href="#doc-regex-extract">#</a> <code>regex_extract</code></h3>
<p><code>regex_extract</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = regex_extract $x
# or in a pipeline:
@list |> map regex_extract |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-regex-replace-str">
<h3><a class="doc-anchor" href="#doc-regex-replace-str">#</a> <code>regex_replace_str</code></h3>
<p><code>regex_replace_str</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = regex_replace_str $x
# or in a pipeline:
@list |> map regex_replace_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-regex-split-str">
<h3><a class="doc-anchor" href="#doc-regex-split-str">#</a> <code>regex_split_str</code></h3>
<p><code>regex_split_str</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = regex_split_str $x
# or in a pipeline:
@list |> map regex_split_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-reject-if">
<h3><a class="doc-anchor" href="#doc-reject-if">#</a> <code>reject_if</code></h3>
<p><code>reject_if</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = reject_if $x
# or in a pipeline:
@list |> map reject_if |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-relativistic-energy">
<h3><a class="doc-anchor" href="#doc-relativistic-energy">#</a> <code>relativistic_energy</code></h3>
<p><code>relativistic_energy</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = relativistic_energy $x
# or in a pipeline:
@list |> map relativistic_energy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-relativistic-mass">
<h3><a class="doc-anchor" href="#doc-relativistic-mass">#</a> <code>relativistic_mass</code></h3>
<p><code>relativistic_mass</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = relativistic_mass $x
# or in a pipeline:
@list |> map relativistic_mass |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-relenergy">
<h3><a class="doc-anchor" href="#doc-relenergy">#</a> <code>relenergy</code></h3>
<p><code>relenergy</code> — physics formulas builtin. Alias for <code>relativistic_energy</code>.</p>
<pre><code class="lang-perl">my $result = relenergy $x
# or in a pipeline:
@list |> map relenergy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-relmass">
<h3><a class="doc-anchor" href="#doc-relmass">#</a> <code>relmass</code></h3>
<p><code>relmass</code> — physics formulas builtin. Alias for <code>relativistic_mass</code>.</p>
<pre><code class="lang-perl">my $result = relmass $x
# or in a pipeline:
@list |> map relmass |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-relu">
<h3><a class="doc-anchor" href="#doc-relu">#</a> <code>relu</code></h3>
<p><code>relu</code> — math functions builtin.</p>
<pre><code class="lang-perl">my $result = relu $x
# or in a pipeline:
@list |> map relu |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-remc">
<h3><a class="doc-anchor" href="#doc-remc">#</a> <code>remc</code></h3>
<p><code>remc</code> — algebraic match builtin. Alias for <code>remove_clj</code>.</p>
<pre><code class="lang-perl">my $result = remc $x
# or in a pipeline:
@list |> map remc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-remove-all-str">
<h3><a class="doc-anchor" href="#doc-remove-all-str">#</a> <code>remove_all_str</code></h3>
<p><code>remove_all_str</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = remove_all_str $x
# or in a pipeline:
@list |> map remove_all_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-remove-at">
<h3><a class="doc-anchor" href="#doc-remove-at">#</a> <code>remove_at</code></h3>
<p><code>remove_at</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = remove_at $x
# or in a pipeline:
@list |> map remove_at |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-remove-clj">
<h3><a class="doc-anchor" href="#doc-remove-clj">#</a> <code>remove_clj</code></h3>
<p><code>remove_clj</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = remove_clj $x
# or in a pipeline:
@list |> map remove_clj |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-remove-consonants">
<h3><a class="doc-anchor" href="#doc-remove-consonants">#</a> <code>remove_consonants</code></h3>
<p><code>remove_consonants</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = remove_consonants $x
# or in a pipeline:
@list |> map remove_consonants |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-remove-elem">
<h3><a class="doc-anchor" href="#doc-remove-elem">#</a> <code>remove_elem</code></h3>
<p><code>remove_elem</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = remove_elem $x
# or in a pipeline:
@list |> map remove_elem |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-remove-first-elem">
<h3><a class="doc-anchor" href="#doc-remove-first-elem">#</a> <code>remove_first_elem</code></h3>
<p><code>remove_first_elem</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = remove_first_elem $x
# or in a pipeline:
@list |> map remove_first_elem |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-remove-keys">
<h3><a class="doc-anchor" href="#doc-remove-keys">#</a> <code>remove_keys</code></h3>
<p><code>remove_keys</code> — hash ops (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = remove_keys $x
# or in a pipeline:
@list |> map remove_keys |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-remove-str">
<h3><a class="doc-anchor" href="#doc-remove-str">#</a> <code>remove_str</code></h3>
<p><code>remove_str</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = remove_str $x
# or in a pipeline:
@list |> map remove_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-remove-vowels">
<h3><a class="doc-anchor" href="#doc-remove-vowels">#</a> <code>remove_vowels</code></h3>
<p><code>remove_vowels</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = remove_vowels $x
# or in a pipeline:
@list |> map remove_vowels |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-remove-whitespace">
<h3><a class="doc-anchor" href="#doc-remove-whitespace">#</a> <code>remove_whitespace</code></h3>
<p><code>remove_whitespace</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = remove_whitespace $x
# or in a pipeline:
@list |> map remove_whitespace |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rep">
<h3><a class="doc-anchor" href="#doc-rep">#</a> <code>rep</code></h3>
<p><code>rep</code> — r base builtin. Alias for <code>rep_fn</code>.</p>
<pre><code class="lang-perl">my $result = rep $x
# or in a pipeline:
@list |> map rep |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rep-fn">
<h3><a class="doc-anchor" href="#doc-rep-fn">#</a> <code>rep_fn</code></h3>
<p><code>rep_fn</code> — repeat a value N times. Like R's rep().</p>
<pre><code class="lang-perl">my @r = @{rep_fn(0, 10)} # ten zeros
my @s = @{rep_fn("x", 5)} # five "x"s
</code></pre>
</article>
<article class="doc-entry" id="doc-repa">
<h3><a class="doc-anchor" href="#doc-repa">#</a> <code>repa</code></h3>
<p><code>repa</code> — javascript array/object methods builtin. Alias for <code>replace_at</code>.</p>
<pre><code class="lang-perl">my $result = repa $x
# or in a pipeline:
@list |> map repa |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-repeat">
<h3><a class="doc-anchor" href="#doc-repeat">#</a> <code>repeat</code></h3>
<p><code>repeat</code> — trivial string ops builtin.</p>
<pre><code class="lang-perl">my $result = repeat $x
# or in a pipeline:
@list |> map repeat |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-repeat-elem">
<h3><a class="doc-anchor" href="#doc-repeat-elem">#</a> <code>repeat_elem</code></h3>
<p><code>repeat_elem</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = repeat_elem $x
# or in a pipeline:
@list |> map repeat_elem |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-repeat-list">
<h3><a class="doc-anchor" href="#doc-repeat-list">#</a> <code>repeat_list</code></h3>
<p><code>repeat_list</code> — collection (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = repeat_list $x
# or in a pipeline:
@list |> map repeat_list |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-repeat-string">
<h3><a class="doc-anchor" href="#doc-repeat-string">#</a> <code>repeat_string</code></h3>
<p><code>repeat_string</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = repeat_string $x
# or in a pipeline:
@list |> map repeat_string |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-repeatedly">
<h3><a class="doc-anchor" href="#doc-repeatedly">#</a> <code>repeatedly</code></h3>
<p><code>repeatedly</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = repeatedly $x
# or in a pipeline:
@list |> map repeatedly |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-replace-all-str">
<h3><a class="doc-anchor" href="#doc-replace-all-str">#</a> <code>replace_all_str</code></h3>
<p><code>replace_all_str</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = replace_all_str $x
# or in a pipeline:
@list |> map replace_all_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-replace-at">
<h3><a class="doc-anchor" href="#doc-replace-at">#</a> <code>replace_at</code></h3>
<p><code>replace_at</code> — javascript array/object methods builtin.</p>
<pre><code class="lang-perl">my $result = replace_at $x
# or in a pipeline:
@list |> map replace_at |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-replace-first">
<h3><a class="doc-anchor" href="#doc-replace-first">#</a> <code>replace_first</code></h3>
<p><code>replace_first</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = replace_first $x
# or in a pipeline:
@list |> map replace_first |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-replace-n-times">
<h3><a class="doc-anchor" href="#doc-replace-n-times">#</a> <code>replace_n_times</code></h3>
<p><code>replace_n_times</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = replace_n_times $x
# or in a pipeline:
@list |> map replace_n_times |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-replace-regex">
<h3><a class="doc-anchor" href="#doc-replace-regex">#</a> <code>replace_regex</code></h3>
<p><code>replace_regex</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = replace_regex $x
# or in a pipeline:
@list |> map replace_regex |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-replicate-val">
<h3><a class="doc-anchor" href="#doc-replicate-val">#</a> <code>replicate_val</code></h3>
<p><code>replicate_val</code> — haskell list functions builtin.</p>
<pre><code class="lang-perl">my $result = replicate_val $x
# or in a pipeline:
@list |> map replicate_val |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-repln">
<h3><a class="doc-anchor" href="#doc-repln">#</a> <code>repln</code></h3>
<p><code>repln</code> — extended stdlib builtin. Alias for <code>replace_n_times</code>.</p>
<pre><code class="lang-perl">my $result = repln $x
# or in a pipeline:
@list |> map repln |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-replre">
<h3><a class="doc-anchor" href="#doc-replre">#</a> <code>replre</code></h3>
<p><code>replre</code> — extended stdlib builtin. Alias for <code>replace_regex</code>.</p>
<pre><code class="lang-perl">my $result = replre $x
# or in a pipeline:
@list |> map replre |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-repv">
<h3><a class="doc-anchor" href="#doc-repv">#</a> <code>repv</code></h3>
<p><code>repv</code> — haskell list functions builtin. Alias for <code>replicate_val</code>.</p>
<pre><code class="lang-perl">my $result = repv $x
# or in a pipeline:
@list |> map repv |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-resample">
<h3><a class="doc-anchor" href="#doc-resample">#</a> <code>resample</code></h3>
<p><code>resample(\@signal, $factor)</code> — resamples signal by a rational factor. Factor > 1 upsamples, factor < 1 downsamples. Uses linear interpolation.</p>
<pre><code class="lang-perl">my $up = resample(\@signal, 2) # double sample rate
my $down = resample(\@signal, 0.5) # halve sample rate
</code></pre>
</article>
<article class="doc-entry" id="doc-reservoir-sample">
<h3><a class="doc-anchor" href="#doc-reservoir-sample">#</a> <code>reservoir_sample</code></h3>
<p><code>reservoir_sample</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = reservoir_sample $x
# or in a pipeline:
@list |> map reservoir_sample |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-reset">
<h3><a class="doc-anchor" href="#doc-reset">#</a> <code>reset</code></h3>
<p><code>reset</code> — process / system builtin.</p>
<pre><code class="lang-perl">my $result = reset $x
# or in a pipeline:
@list |> map reset |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-resfreq">
<h3><a class="doc-anchor" href="#doc-resfreq">#</a> <code>resfreq</code></h3>
<p><code>resfreq</code> — physics formulas builtin. Alias for <code>resonant_frequency</code>.</p>
<pre><code class="lang-perl">my $result = resfreq $x
# or in a pipeline:
@list |> map resfreq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-resonant-frequency">
<h3><a class="doc-anchor" href="#doc-resonant-frequency">#</a> <code>resonant_frequency</code></h3>
<p><code>resonant_frequency</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = resonant_frequency $x
# or in a pipeline:
@list |> map resonant_frequency |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rest">
<h3><a class="doc-anchor" href="#doc-rest">#</a> <code>rest</code></h3>
<p><code>rest</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = rest $x
# or in a pipeline:
@list |> map rest |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rest-energy">
<h3><a class="doc-anchor" href="#doc-rest-energy">#</a> <code>rest_energy</code></h3>
<p><code>rest_energy</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = rest_energy $x
# or in a pipeline:
@list |> map rest_energy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-restenergy">
<h3><a class="doc-anchor" href="#doc-restenergy">#</a> <code>restenergy</code></h3>
<p><code>restenergy</code> — physics formulas builtin. Alias for <code>rest_energy</code>.</p>
<pre><code class="lang-perl">my $result = restenergy $x
# or in a pipeline:
@list |> map restenergy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rev">
<h3><a class="doc-anchor" href="#doc-rev">#</a> <code>rev</code></h3>
<p><code>rev</code> — short aliases builtin.</p>
<pre><code class="lang-perl">my $result = rev $x
# or in a pipeline:
@list |> map rev |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rev-str">
<h3><a class="doc-anchor" href="#doc-rev-str">#</a> <code>rev_str</code></h3>
<p><code>rev_str</code> — trivial string ops builtin. Alias for <code>reverse_str</code>.</p>
<pre><code class="lang-perl">my $result = rev_str $x
# or in a pipeline:
@list |> map rev_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rev-vec">
<h3><a class="doc-anchor" href="#doc-rev-vec">#</a> <code>rev_vec</code></h3>
<p><code>rev_vec</code> — r base builtin.</p>
<pre><code class="lang-perl">my $result = rev_vec $x
# or in a pipeline:
@list |> map rev_vec |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-reverse-each">
<h3><a class="doc-anchor" href="#doc-reverse-each">#</a> <code>reverse_each</code></h3>
<p><code>reverse_each</code> — trivial numeric helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = reverse_each $x
# or in a pipeline:
@list |> map reverse_each |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-reverse-each-word">
<h3><a class="doc-anchor" href="#doc-reverse-each-word">#</a> <code>reverse_each_word</code></h3>
<p><code>reverse_each_word</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = reverse_each_word $x
# or in a pipeline:
@list |> map reverse_each_word |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-reverse-list">
<h3><a class="doc-anchor" href="#doc-reverse-list">#</a> <code>reverse_list</code></h3>
<p><code>reverse_list</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = reverse_list $x
# or in a pipeline:
@list |> map reverse_list |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-reverse-str">
<h3><a class="doc-anchor" href="#doc-reverse-str">#</a> <code>reverse_str</code></h3>
<p><code>reverse_str</code> — trivial string ops builtin.</p>
<pre><code class="lang-perl">my $result = reverse_str $x
# or in a pipeline:
@list |> map reverse_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-reverse-words">
<h3><a class="doc-anchor" href="#doc-reverse-words">#</a> <code>reverse_words</code></h3>
<p><code>reverse_words</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = reverse_words $x
# or in a pipeline:
@list |> map reverse_words |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-revwords">
<h3><a class="doc-anchor" href="#doc-revwords">#</a> <code>revwords</code></h3>
<p><code>revwords</code> — string processing (uncategorized batch) builtin. Alias for <code>reverse_each_word</code>.</p>
<pre><code class="lang-perl">my $result = revwords $x
# or in a pipeline:
@list |> map revwords |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rexp">
<h3><a class="doc-anchor" href="#doc-rexp">#</a> <code>rexp</code></h3>
<p><code>rexp</code> — generate n random exponential variates. Args: n [, rate]. Like R's rexp().</p>
<pre><code class="lang-perl">my @x = @{rexp(100, 0.5)} # rate=0.5 (mean=2)
</code></pre>
</article>
<article class="doc-entry" id="doc-rf">
<h3><a class="doc-anchor" href="#doc-rf">#</a> <code>rf</code></h3>
<p><code>rf</code> — generate n random F variates. Args: n, d1, d2. Like R's rf().</p>
<pre><code class="lang-perl">my @x = @{rf(100, 5, 10)} # F(5,10)
</code></pre>
</article>
<article class="doc-entry" id="doc-rfact">
<h3><a class="doc-anchor" href="#doc-rfact">#</a> <code>rfact</code></h3>
<p><code>rfact</code> — math formulas builtin. Alias for <code>rising_factorial</code>.</p>
<pre><code class="lang-perl">my $result = rfact $x
# or in a pipeline:
@list |> map rfact |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rgamma">
<h3><a class="doc-anchor" href="#doc-rgamma">#</a> <code>rgamma</code></h3>
<p><code>rgamma</code> — generate n random gamma variates. Args: n, shape [, scale]. Like R's rgamma().</p>
<pre><code class="lang-perl">my @x = @{rgamma(100, 2, 1)} # Gamma(2,1)
</code></pre>
</article>
<article class="doc-entry" id="doc-rgb">
<h3><a class="doc-anchor" href="#doc-rgb">#</a> <code>rgb</code></h3>
<p><code>rgb</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = rgb $x
# or in a pipeline:
@list |> map rgb |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rgb2hsl">
<h3><a class="doc-anchor" href="#doc-rgb2hsl">#</a> <code>rgb2hsl</code></h3>
<p><code>rgb2hsl</code> — color operations builtin. Alias for <code>rgb_to_hsl</code>.</p>
<pre><code class="lang-perl">my $result = rgb2hsl $x
# or in a pipeline:
@list |> map rgb2hsl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rgb2hsv">
<h3><a class="doc-anchor" href="#doc-rgb2hsv">#</a> <code>rgb2hsv</code></h3>
<p><code>rgb2hsv</code> — color operations builtin. Alias for <code>rgb_to_hsv</code>.</p>
<pre><code class="lang-perl">my $result = rgb2hsv $x
# or in a pipeline:
@list |> map rgb2hsv |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rgb-to-hex">
<h3><a class="doc-anchor" href="#doc-rgb-to-hex">#</a> <code>rgb_to_hex</code></h3>
<p><code>rgb_to_hex</code> — color / ansi builtin.</p>
<pre><code class="lang-perl">my $result = rgb_to_hex $input
</code></pre>
</article>
<article class="doc-entry" id="doc-rgb-to-hsl">
<h3><a class="doc-anchor" href="#doc-rgb-to-hsl">#</a> <code>rgb_to_hsl</code></h3>
<p><code>rgb_to_hsl</code> — color operations builtin.</p>
<pre><code class="lang-perl">my $result = rgb_to_hsl $input
</code></pre>
</article>
<article class="doc-entry" id="doc-rgb-to-hsv">
<h3><a class="doc-anchor" href="#doc-rgb-to-hsv">#</a> <code>rgb_to_hsv</code></h3>
<p><code>rgb_to_hsv</code> — color operations builtin.</p>
<pre><code class="lang-perl">my $result = rgb_to_hsv $input
</code></pre>
</article>
<article class="doc-entry" id="doc-rgeom">
<h3><a class="doc-anchor" href="#doc-rgeom">#</a> <code>rgeom</code></h3>
<p><code>rgeom</code> — generate n random geometric variates. Args: n, prob.</p>
<pre><code class="lang-perl">my @x = @{rgeom(100, 0.3)} # trials until first success
</code></pre>
</article>
<article class="doc-entry" id="doc-rho">
<h3><a class="doc-anchor" href="#doc-rho">#</a> <code>rho</code></h3>
<p><code>spearman</code> (aliases <code>spearman_corr</code>, <code>rho</code>) computes Spearman's rank correlation coefficient between two samples.</p>
<pre><code class="lang-perl">p rho([1,2,3,4,5], [5,6,7,8,7]) # ~0.82
</code></pre>
</article>
<article class="doc-entry" id="doc-ridx">
<h3><a class="doc-anchor" href="#doc-ridx">#</a> <code>ridx</code></h3>
<p><code>ridx</code> — python/ruby stdlib builtin. Alias for <code>rindex_fn</code>.</p>
<pre><code class="lang-perl">my $result = ridx $x
# or in a pipeline:
@list |> map ridx |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-riffle">
<h3><a class="doc-anchor" href="#doc-riffle">#</a> <code>riffle</code></h3>
<p><code>riffle</code> — collection helpers (trivial) builtin.</p>
<pre><code class="lang-perl">my $result = riffle $x
# or in a pipeline:
@list |> map riffle |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-right-str">
<h3><a class="doc-anchor" href="#doc-right-str">#</a> <code>right_str</code></h3>
<p><code>right_str</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = right_str $x
# or in a pipeline:
@list |> map right_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rindex-fn">
<h3><a class="doc-anchor" href="#doc-rindex-fn">#</a> <code>rindex_fn</code></h3>
<p><code>rindex_fn</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = rindex_fn $x
# or in a pipeline:
@list |> map rindex_fn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rising-factorial">
<h3><a class="doc-anchor" href="#doc-rising-factorial">#</a> <code>rising_factorial</code></h3>
<p><code>rising_factorial</code> — math formulas builtin.</p>
<pre><code class="lang-perl">my $result = rising_factorial $x
# or in a pipeline:
@list |> map rising_factorial |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rjt">
<h3><a class="doc-anchor" href="#doc-rjt">#</a> <code>rjt</code></h3>
<p><code>rjt</code> — extended stdlib builtin. Alias for <code>rjust_text</code>.</p>
<pre><code class="lang-perl">my $result = rjt $x
# or in a pipeline:
@list |> map rjt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rjust">
<h3><a class="doc-anchor" href="#doc-rjust">#</a> <code>rjust</code></h3>
<p><code>rjust</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = rjust $x
# or in a pipeline:
@list |> map rjust |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rjust-text">
<h3><a class="doc-anchor" href="#doc-rjust-text">#</a> <code>rjust_text</code></h3>
<p><code>rjust_text</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = rjust_text $x
# or in a pipeline:
@list |> map rjust_text |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rk4">
<h3><a class="doc-anchor" href="#doc-rk4">#</a> <code>rk4</code></h3>
<p><code>rk4</code> (aliases <code>runge_kutta</code>, <code>rk4_ode</code>) solves an ODE dy/dt = f(t,y) using 4th-order Runge-Kutta. Returns [[t,y], ...].</p>
<pre><code class="lang-perl"># dy/dt = -y, y(0) = 1 → y = e^(-t)
my $sol = rk4(fn { -$_[1] }, 0, 1, 0.1, 100)
</code></pre>
</article>
<article class="doc-entry" id="doc-rl-time-constant">
<h3><a class="doc-anchor" href="#doc-rl-time-constant">#</a> <code>rl_time_constant</code></h3>
<p><code>rl_time_constant</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = rl_time_constant $x
# or in a pipeline:
@list |> map rl_time_constant |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rld">
<h3><a class="doc-anchor" href="#doc-rld">#</a> <code>rld</code></h3>
<p><code>rld</code> — collection more builtin. Alias for <code>run_length_decode</code>.</p>
<pre><code class="lang-perl">my $result = rld $x
# or in a pipeline:
@list |> map rld |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rld-str">
<h3><a class="doc-anchor" href="#doc-rld-str">#</a> <code>rld_str</code></h3>
<p><code>rld_str</code> — matrix operations (uncategorized batch) builtin. Alias for <code>run_length_decode_str</code>.</p>
<pre><code class="lang-perl">my $result = rld_str $x
# or in a pipeline:
@list |> map rld_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rle">
<h3><a class="doc-anchor" href="#doc-rle">#</a> <code>rle</code></h3>
<p><code>rle</code> — collection more builtin. Alias for <code>run_length_encode</code>.</p>
<pre><code class="lang-perl">my $result = rle $x
# or in a pipeline:
@list |> map rle |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rle-str">
<h3><a class="doc-anchor" href="#doc-rle-str">#</a> <code>rle_str</code></h3>
<p><code>rle_str</code> — matrix operations (uncategorized batch) builtin. Alias for <code>run_length_encode_str</code>.</p>
<pre><code class="lang-perl">my $result = rle_str $x
# or in a pipeline:
@list |> map rle_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rlnorm">
<h3><a class="doc-anchor" href="#doc-rlnorm">#</a> <code>rlnorm</code></h3>
<p><code>rlnorm</code> — generate n random log-normal variates. Args: n [, mu, sigma].</p>
<pre><code class="lang-perl">my @x = @{rlnorm(100, 0, 1)} # LogN(0,1)
</code></pre>
</article>
<article class="doc-entry" id="doc-rltau">
<h3><a class="doc-anchor" href="#doc-rltau">#</a> <code>rltau</code></h3>
<p><code>rltau</code> — physics formulas builtin. Alias for <code>rl_time_constant</code>.</p>
<pre><code class="lang-perl">my $result = rltau $x
# or in a pipeline:
@list |> map rltau |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rmall">
<h3><a class="doc-anchor" href="#doc-rmall">#</a> <code>rmall</code></h3>
<p><code>rmall</code> — extended stdlib builtin. Alias for <code>remove_all_str</code>.</p>
<pre><code class="lang-perl">my $result = rmall $x
# or in a pipeline:
@list |> map rmall |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rmcons">
<h3><a class="doc-anchor" href="#doc-rmcons">#</a> <code>rmcons</code></h3>
<p><code>rmcons</code> — string processing (uncategorized batch) builtin. Alias for <code>remove_consonants</code>.</p>
<pre><code class="lang-perl">my $result = rmcons $x
# or in a pipeline:
@list |> map rmcons |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rms">
<h3><a class="doc-anchor" href="#doc-rms">#</a> <code>rms</code></h3>
<p><code>rms</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = rms $x
# or in a pipeline:
@list |> map rms |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rmse">
<h3><a class="doc-anchor" href="#doc-rmse">#</a> <code>rmse</code></h3>
<p><code>rmse</code> — math functions builtin.</p>
<pre><code class="lang-perl">my $result = rmse $x
# or in a pipeline:
@list |> map rmse |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rmvowel">
<h3><a class="doc-anchor" href="#doc-rmvowel">#</a> <code>rmvowel</code></h3>
<p><code>rmvowel</code> — string processing (uncategorized batch) builtin. Alias for <code>remove_vowels</code>.</p>
<pre><code class="lang-perl">my $result = rmvowel $x
# or in a pipeline:
@list |> map rmvowel |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rmws">
<h3><a class="doc-anchor" href="#doc-rmws">#</a> <code>rmws</code></h3>
<p><code>rmws</code> — extended stdlib builtin. Alias for <code>remove_whitespace</code>.</p>
<pre><code class="lang-perl">my $result = rmws $x
# or in a pipeline:
@list |> map rmws |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rngcmp">
<h3><a class="doc-anchor" href="#doc-rngcmp">#</a> <code>rngcmp</code></h3>
<p><code>rngcmp</code> — matrix operations (uncategorized batch) builtin. Alias for <code>range_compress</code>.</p>
<pre><code class="lang-perl">my $result = rngcmp $x
# or in a pipeline:
@list |> map rngcmp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rngexp">
<h3><a class="doc-anchor" href="#doc-rngexp">#</a> <code>rngexp</code></h3>
<p><code>rngexp</code> — matrix operations (uncategorized batch) builtin. Alias for <code>range_expand</code>.</p>
<pre><code class="lang-perl">my $result = rngexp $x
# or in a pipeline:
@list |> map rngexp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rnk">
<h3><a class="doc-anchor" href="#doc-rnk">#</a> <code>rnk</code></h3>
<p><code>rnk</code> — extended stdlib builtin. Alias for <code>rank</code>.</p>
<pre><code class="lang-perl">my $result = rnk $x
# or in a pipeline:
@list |> map rnk |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rnorm">
<h3><a class="doc-anchor" href="#doc-rnorm">#</a> <code>rnorm</code></h3>
<p><code>rnorm</code> — generate n random normal variates. Args: n [, mu, sigma]. Like R's rnorm().</p>
<pre><code class="lang-perl">my @x = @{rnorm(1000)} # 1000 standard normal
my @y = @{rnorm(100, 50, 10)} # mean=50, sd=10
</code></pre>
</article>
<article class="doc-entry" id="doc-roi">
<h3><a class="doc-anchor" href="#doc-roi">#</a> <code>roi</code></h3>
<p><code>roi</code> — finance builtin.</p>
<pre><code class="lang-perl">my $result = roi $x
# or in a pipeline:
@list |> map roi |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-roman">
<h3><a class="doc-anchor" href="#doc-roman">#</a> <code>roman</code></h3>
<p><code>roman</code> — roman numerals builtin. Alias for <code>int_to_roman</code>.</p>
<pre><code class="lang-perl">my $result = roman $x
# or in a pipeline:
@list |> map roman |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-roman-add">
<h3><a class="doc-anchor" href="#doc-roman-add">#</a> <code>roman_add</code></h3>
<p><code>roman_add</code> — roman numerals builtin.</p>
<pre><code class="lang-perl">my $result = roman_add $x
# or in a pipeline:
@list |> map roman_add |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-roman-numeral-list">
<h3><a class="doc-anchor" href="#doc-roman-numeral-list">#</a> <code>roman_numeral_list</code></h3>
<p><code>roman_numeral_list</code> — roman numerals builtin.</p>
<pre><code class="lang-perl">my $result = roman_numeral_list $x
# or in a pipeline:
@list |> map roman_numeral_list |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-roman-to-int">
<h3><a class="doc-anchor" href="#doc-roman-to-int">#</a> <code>roman_to_int</code></h3>
<p><code>roman_to_int</code> — roman numerals builtin.</p>
<pre><code class="lang-perl">my $result = roman_to_int $input
</code></pre>
</article>
<article class="doc-entry" id="doc-romanlist">
<h3><a class="doc-anchor" href="#doc-romanlist">#</a> <code>romanlist</code></h3>
<p><code>romanlist</code> — roman numerals builtin. Alias for <code>roman_numeral_list</code>.</p>
<pre><code class="lang-perl">my $result = romanlist $x
# or in a pipeline:
@list |> map romanlist |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rot13">
<h3><a class="doc-anchor" href="#doc-rot13">#</a> <code>rot13</code></h3>
<p><code>rot13</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = rot13 $x
# or in a pipeline:
@list |> map rot13 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rot47">
<h3><a class="doc-anchor" href="#doc-rot47">#</a> <code>rot47</code></h3>
<p><code>rot47</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = rot47 $x
# or in a pipeline:
@list |> map rot47 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rotate">
<h3><a class="doc-anchor" href="#doc-rotate">#</a> <code>rotate</code></h3>
<p><code>rotate</code> — collection helpers (trivial) builtin.</p>
<pre><code class="lang-perl">my $result = rotate $x
# or in a pipeline:
@list |> map rotate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rotate-point">
<h3><a class="doc-anchor" href="#doc-rotate-point">#</a> <code>rotate_point</code></h3>
<p><code>rotate_point</code> — math functions builtin.</p>
<pre><code class="lang-perl">my $result = rotate_point $x
# or in a pipeline:
@list |> map rotate_point |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-round">
<h3><a class="doc-anchor" href="#doc-round">#</a> <code>round</code></h3>
<p><code>round</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = round $x
# or in a pipeline:
@list |> map round |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-round-each">
<h3><a class="doc-anchor" href="#doc-round-each">#</a> <code>round_each</code></h3>
<p><code>round_each</code> — trivial numeric helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = round_each $x
# or in a pipeline:
@list |> map round_each |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-round-to">
<h3><a class="doc-anchor" href="#doc-round-to">#</a> <code>round_to</code></h3>
<p><code>round_to</code> — math functions builtin.</p>
<pre><code class="lang-perl">my $result = round_to $x
# or in a pipeline:
@list |> map round_to |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rowmeans">
<h3><a class="doc-anchor" href="#doc-rowmeans">#</a> <code>rowMeans</code></h3>
<p><code>row_means</code> (alias <code>rowMeans</code>) — mean of each row. Like R's rowMeans().</p>
<pre><code class="lang-perl">p rowMeans([[2,4],[6,8]]) # [3, 7]
</code></pre>
</article>
<article class="doc-entry" id="doc-rowsums">
<h3><a class="doc-anchor" href="#doc-rowsums">#</a> <code>rowSums</code></h3>
<p><code>row_sums</code> (alias <code>rowSums</code>) — sum of each row in a matrix. Like R's rowSums().</p>
<pre><code class="lang-perl">p row_sums([[1,2,3],[4,5,6]]) # [6, 15]
</code></pre>
</article>
<article class="doc-entry" id="doc-rpad">
<h3><a class="doc-anchor" href="#doc-rpad">#</a> <code>rpad</code></h3>
<p><code>rpad</code> — trivial string ops builtin. Alias for <code>pad_right</code>.</p>
<pre><code class="lang-perl">my $result = rpad $x
# or in a pipeline:
@list |> map rpad |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rpn">
<h3><a class="doc-anchor" href="#doc-rpn">#</a> <code>rpn</code></h3>
<p><code>rpn</code> — algorithms / puzzles builtin. Alias for <code>eval_rpn</code>.</p>
<pre><code class="lang-perl">my $result = rpn $x
# or in a pipeline:
@list |> map rpn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rpois">
<h3><a class="doc-anchor" href="#doc-rpois">#</a> <code>rpois</code></h3>
<p><code>rpois</code> — generate n random Poisson variates. Args: n, lambda. Like R's rpois().</p>
<pre><code class="lang-perl">my @x = @{rpois(100, 5)} # Poisson with mean 5
</code></pre>
</article>
<article class="doc-entry" id="doc-rptd">
<h3><a class="doc-anchor" href="#doc-rptd">#</a> <code>rptd</code></h3>
<p><code>rptd</code> — algebraic match builtin. Alias for <code>repeatedly</code>.</p>
<pre><code class="lang-perl">my $result = rptd $x
# or in a pipeline:
@list |> map rptd |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rsa-decrypt-pkcs1">
<h3><a class="doc-anchor" href="#doc-rsa-decrypt-pkcs1">#</a> <code>rsa_decrypt_pkcs1</code></h3>
<p><code>rsa_decrypt_pkcs1</code> decrypts RSA-PKCS1v15 ciphertext.</p>
<pre><code class="lang-perl">my $plain = rsa_decrypt_pkcs1($priv, $cipher)
</code></pre>
</article>
<article class="doc-entry" id="doc-rsa-encrypt-pkcs1">
<h3><a class="doc-anchor" href="#doc-rsa-encrypt-pkcs1">#</a> <code>rsa_encrypt_pkcs1</code></h3>
<p><code>rsa_encrypt_pkcs1</code> encrypts with legacy RSA-PKCS1v15 padding. Only for compatibility with old systems — prefer OAEP.</p>
<pre><code class="lang-perl">my $cipher = rsa_encrypt_pkcs1($pub, "data")
</code></pre>
</article>
<article class="doc-entry" id="doc-rsamp">
<h3><a class="doc-anchor" href="#doc-rsamp">#</a> <code>rsamp</code></h3>
<p><code>rsamp</code> — matrix operations (uncategorized batch) builtin. Alias for <code>reservoir_sample</code>.</p>
<pre><code class="lang-perl">my $result = rsamp $x
# or in a pipeline:
@list |> map rsamp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rst">
<h3><a class="doc-anchor" href="#doc-rst">#</a> <code>rst</code></h3>
<p><code>rst</code> — algebraic match builtin. Alias for <code>rest</code>.</p>
<pre><code class="lang-perl">my $result = rst $x
# or in a pipeline:
@list |> map rst |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rsun">
<h3><a class="doc-anchor" href="#doc-rsun">#</a> <code>rsun</code></h3>
<p><code>rsun</code> — physics constants builtin. Alias for <code>sun_radius</code>.</p>
<pre><code class="lang-perl">my $result = rsun $x
# or in a pipeline:
@list |> map rsun |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rt">
<h3><a class="doc-anchor" href="#doc-rt">#</a> <code>rt</code></h3>
<p><code>rt</code> — generate n random Student's t variates. Args: n, df. Like R's rt().</p>
<pre><code class="lang-perl">my @x = @{rt(100, 10)} # t with 10 df
</code></pre>
</article>
<article class="doc-entry" id="doc-run-length-decode">
<h3><a class="doc-anchor" href="#doc-run-length-decode">#</a> <code>run_length_decode</code></h3>
<p><code>run_length_decode</code> — collection more builtin.</p>
<pre><code class="lang-perl">my $result = run_length_decode $x
# or in a pipeline:
@list |> map run_length_decode |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-run-length-decode-str">
<h3><a class="doc-anchor" href="#doc-run-length-decode-str">#</a> <code>run_length_decode_str</code></h3>
<p><code>run_length_decode_str</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = run_length_decode_str $x
# or in a pipeline:
@list |> map run_length_decode_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-run-length-encode">
<h3><a class="doc-anchor" href="#doc-run-length-encode">#</a> <code>run_length_encode</code></h3>
<p><code>run_length_encode</code> — collection more builtin.</p>
<pre><code class="lang-perl">my $result = run_length_encode $x
# or in a pipeline:
@list |> map run_length_encode |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-run-length-encode-str">
<h3><a class="doc-anchor" href="#doc-run-length-encode-str">#</a> <code>run_length_encode_str</code></h3>
<p><code>run_length_encode_str</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = run_length_encode_str $x
# or in a pipeline:
@list |> map run_length_encode_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-runif">
<h3><a class="doc-anchor" href="#doc-runif">#</a> <code>runif</code></h3>
<p><code>runif</code> — generate n random uniform variates. Args: n [, min, max]. Like R's runif().</p>
<pre><code class="lang-perl">my @x = @{runif(100, 0, 1)} # 100 uniform [0,1]
</code></pre>
</article>
<article class="doc-entry" id="doc-running-max">
<h3><a class="doc-anchor" href="#doc-running-max">#</a> <code>running_max</code></h3>
<p><code>running_max</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = running_max $x
# or in a pipeline:
@list |> map running_max |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-running-min">
<h3><a class="doc-anchor" href="#doc-running-min">#</a> <code>running_min</code></h3>
<p><code>running_min</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = running_min $x
# or in a pipeline:
@list |> map running_min |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-running-reduce">
<h3><a class="doc-anchor" href="#doc-running-reduce">#</a> <code>running_reduce</code></h3>
<p><code>running_reduce</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = running_reduce $x
# or in a pipeline:
@list |> map running_reduce |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-runred">
<h3><a class="doc-anchor" href="#doc-runred">#</a> <code>runred</code></h3>
<p><code>runred</code> — additional missing stdlib functions builtin. Alias for <code>running_reduce</code>.</p>
<pre><code class="lang-perl">my $result = runred $x
# or in a pipeline:
@list |> map runred |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rweibull">
<h3><a class="doc-anchor" href="#doc-rweibull">#</a> <code>rweibull</code></h3>
<p><code>rweibull</code> — generate n random Weibull variates. Args: n, shape [, scale].</p>
<pre><code class="lang-perl">my @x = @{rweibull(100, 2, 1)} # Weibull(2,1)
</code></pre>
</article>
<article class="doc-entry" id="doc-rydberg">
<h3><a class="doc-anchor" href="#doc-rydberg">#</a> <code>rydberg</code></h3>
<p><code>rydberg</code> — physics constants builtin. Alias for <code>rydberg_constant</code>.</p>
<pre><code class="lang-perl">my $result = rydberg $x
# or in a pipeline:
@list |> map rydberg |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-rydberg-constant">
<h3><a class="doc-anchor" href="#doc-rydberg-constant">#</a> <code>rydberg_constant</code></h3>
<p><code>rydberg_constant</code> — physics constants builtin.</p>
<pre><code class="lang-perl">my $result = rydberg_constant $x
# or in a pipeline:
@list |> map rydberg_constant |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-s1">
<h3><a class="doc-anchor" href="#doc-s1">#</a> <code>s1</code></h3>
<p><code>s1</code> — crypto / encoding builtin. Alias for <code>sha1</code>.</p>
<pre><code class="lang-perl">my $result = s1 $x
# or in a pipeline:
@list |> map s1 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-s224">
<h3><a class="doc-anchor" href="#doc-s224">#</a> <code>s224</code></h3>
<p><code>s224</code> — crypto / encoding builtin. Alias for <code>sha224</code>.</p>
<pre><code class="lang-perl">my $result = s224 $x
# or in a pipeline:
@list |> map s224 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-s256">
<h3><a class="doc-anchor" href="#doc-s256">#</a> <code>s256</code></h3>
<p><code>s256</code> — crypto / encoding builtin. Alias for <code>sha256</code>.</p>
<pre><code class="lang-perl">my $result = s256 $x
# or in a pipeline:
@list |> map s256 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-s2c">
<h3><a class="doc-anchor" href="#doc-s2c">#</a> <code>s2c</code></h3>
<p><code>s2c</code> — string processing (uncategorized batch) builtin. Alias for <code>snake_to_camel</code>.</p>
<pre><code class="lang-perl">my $result = s2c $x
# or in a pipeline:
@list |> map s2c |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-s384">
<h3><a class="doc-anchor" href="#doc-s384">#</a> <code>s384</code></h3>
<p><code>s384</code> — crypto / encoding builtin. Alias for <code>sha384</code>.</p>
<pre><code class="lang-perl">my $result = s384 $x
# or in a pipeline:
@list |> map s384 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-s512">
<h3><a class="doc-anchor" href="#doc-s512">#</a> <code>s512</code></h3>
<p><code>s512</code> — crypto / encoding builtin. Alias for <code>sha512</code>.</p>
<pre><code class="lang-perl">my $result = s512 $x
# or in a pipeline:
@list |> map s512 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-s-to-m">
<h3><a class="doc-anchor" href="#doc-s-to-m">#</a> <code>s_to_m</code></h3>
<p><code>s_to_m</code> — unit conversions builtin. Alias for <code>seconds_to_minutes</code>.</p>
<pre><code class="lang-perl">my $result = s_to_m $input
</code></pre>
</article>
<article class="doc-entry" id="doc-s-to-ms">
<h3><a class="doc-anchor" href="#doc-s-to-ms">#</a> <code>s_to_ms</code></h3>
<p><code>s_to_ms</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = s_to_ms $input
</code></pre>
</article>
<article class="doc-entry" id="doc-safe-div">
<h3><a class="doc-anchor" href="#doc-safe-div">#</a> <code>safe_div</code></h3>
<p><code>safe_div</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = safe_div $x
# or in a pipeline:
@list |> map safe_div |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-safe-log">
<h3><a class="doc-anchor" href="#doc-safe-log">#</a> <code>safe_log</code></h3>
<p><code>safe_log</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = safe_log $x
# or in a pipeline:
@list |> map safe_log |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-safe-mod">
<h3><a class="doc-anchor" href="#doc-safe-mod">#</a> <code>safe_mod</code></h3>
<p><code>safe_mod</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = safe_mod $x
# or in a pipeline:
@list |> map safe_mod |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-safe-sqrt">
<h3><a class="doc-anchor" href="#doc-safe-sqrt">#</a> <code>safe_sqrt</code></h3>
<p><code>safe_sqrt</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = safe_sqrt $x
# or in a pipeline:
@list |> map safe_sqrt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sample-n">
<h3><a class="doc-anchor" href="#doc-sample-n">#</a> <code>sample_n</code></h3>
<p><code>sample_n</code> — collection (batch 2) builtin. Alias for <code>random_sample</code>.</p>
<pre><code class="lang-perl">my $result = sample_n $x
# or in a pipeline:
@list |> map sample_n |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sample-one">
<h3><a class="doc-anchor" href="#doc-sample-one">#</a> <code>sample_one</code></h3>
<p><code>sample_one</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = sample_one $x
# or in a pipeline:
@list |> map sample_one |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sample-stddev">
<h3><a class="doc-anchor" href="#doc-sample-stddev">#</a> <code>sample_stddev</code></h3>
<p><code>sample_stddev</code> — statistics (extended) builtin.</p>
<pre><code class="lang-perl">my $result = sample_stddev $x
# or in a pipeline:
@list |> map sample_stddev |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sample-variance">
<h3><a class="doc-anchor" href="#doc-sample-variance">#</a> <code>sample_variance</code></h3>
<p><code>sample_variance</code> — statistics (extended) builtin.</p>
<pre><code class="lang-perl">my $result = sample_variance $x
# or in a pipeline:
@list |> map sample_variance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sampn">
<h3><a class="doc-anchor" href="#doc-sampn">#</a> <code>sampn</code></h3>
<p><code>sampn</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = sampn $x
# or in a pipeline:
@list |> map sampn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sapply">
<h3><a class="doc-anchor" href="#doc-sapply">#</a> <code>sapply</code></h3>
<p><code>sapply</code> — apply a function to each element, return a vector. Like R's sapply().</p>
<pre><code class="lang-perl">my @sq = @{sapply([1,2,3,4], fn { $_[0] ** 2 })} # [1,4,9,16]
</code></pre>
</article>
<article class="doc-entry" id="doc-sat01">
<h3><a class="doc-anchor" href="#doc-sat01">#</a> <code>sat01</code></h3>
<p><code>sat01</code> — trig / math (batch 2) builtin. Alias for <code>saturate</code>.</p>
<pre><code class="lang-perl">my $result = sat01 $x
# or in a pipeline:
@list |> map sat01 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-saturate">
<h3><a class="doc-anchor" href="#doc-saturate">#</a> <code>saturate</code></h3>
<p><code>saturate</code> — trig / math (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = saturate $x
# or in a pipeline:
@list |> map saturate |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-scale">
<h3><a class="doc-anchor" href="#doc-scale">#</a> <code>scale</code></h3>
<p><code>scale</code> — standardize a vector: (x - mean) / sd. Like R's scale().</p>
<pre><code class="lang-perl">my @z = @{scale([10,20,30])} # [-1, 0, 1]
</code></pre>
</article>
<article class="doc-entry" id="doc-scale-each">
<h3><a class="doc-anchor" href="#doc-scale-each">#</a> <code>scale_each</code></h3>
<p><code>scale_each</code> — trivial numeric helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = scale_each $x
# or in a pipeline:
@list |> map scale_each |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-scale-point">
<h3><a class="doc-anchor" href="#doc-scale-point">#</a> <code>scale_point</code></h3>
<p><code>scale_point($x, $y, $sx, $sy)</code> — scales a 2D point by factors sx and sy from the origin. Returns [$x*$sx, $y*$sy]. Use for geometric transformations.</p>
<pre><code class="lang-perl">my $p = scale_point(2, 3, 2, 2)
p @$p # (4, 6)
</code></pre>
</article>
<article class="doc-entry" id="doc-scalept">
<h3><a class="doc-anchor" href="#doc-scalept">#</a> <code>scalept</code></h3>
<p><code>scalept</code> — geometry (extended) builtin. Alias for <code>scale_point</code>.</p>
<pre><code class="lang-perl">my $result = scalept $x
# or in a pipeline:
@list |> map scalept |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-scan">
<h3><a class="doc-anchor" href="#doc-scan">#</a> <code>scan</code></h3>
<p><code>scan</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = scan $x
# or in a pipeline:
@list |> map scan |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-scan-left">
<h3><a class="doc-anchor" href="#doc-scan-left">#</a> <code>scan_left</code></h3>
<p><code>scan_left</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = scan_left $x
# or in a pipeline:
@list |> map scan_left |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-scanl">
<h3><a class="doc-anchor" href="#doc-scanl">#</a> <code>scanl</code></h3>
<p><code>scanl</code> — haskell list functions builtin.</p>
<pre><code class="lang-perl">my $result = scanl $x
# or in a pipeline:
@list |> map scanl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-scanr">
<h3><a class="doc-anchor" href="#doc-scanr">#</a> <code>scanr</code></h3>
<p><code>scanr</code> — haskell list functions builtin.</p>
<pre><code class="lang-perl">my $result = scanr $x
# or in a pipeline:
@list |> map scanr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-scentroid">
<h3><a class="doc-anchor" href="#doc-scentroid">#</a> <code>scentroid</code></h3>
<p><code>spectral_centroid(\@spectrum)</code> (alias <code>scentroid</code>) — computes the spectral centroid (center of mass) of a spectrum. Indicates the 'brightness' of a sound. Returns frequency bin index.</p>
<pre><code class="lang-perl">my $psd = psd(\@signal)
p scentroid($psd) # brightness measure
</code></pre>
</article>
<article class="doc-entry" id="doc-schwarz">
<h3><a class="doc-anchor" href="#doc-schwarz">#</a> <code>schwarz</code></h3>
<p><code>schwarzschild_radius($mass)</code> (alias <code>schwarz</code>) — event horizon radius rs = 2GM/c² of a black hole.</p>
<pre><code class="lang-perl">p schwarz(1.989e30) # ~2954 m (Sun as black hole)
p schwarz(5.972e24) # ~0.009 m (Earth as black hole)
</code></pre>
</article>
<article class="doc-entry" id="doc-script-name">
<h3><a class="doc-anchor" href="#doc-script-name">#</a> <code>script_name</code></h3>
<p><code>script_name</code> — process / env builtin.</p>
<pre><code class="lang-perl">my $result = script_name $x
# or in a pipeline:
@list |> map script_name |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sdivs">
<h3><a class="doc-anchor" href="#doc-sdivs">#</a> <code>sdivs</code></h3>
<p><code>sdivs</code> — math / numeric (uncategorized batch) builtin. Alias for <code>sum_divisors</code>.</p>
<pre><code class="lang-perl">my $result = sdivs $x
# or in a pipeline:
@list |> map sdivs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sdx">
<h3><a class="doc-anchor" href="#doc-sdx">#</a> <code>sdx</code></h3>
<p><code>sdx</code> — extended stdlib builtin. Alias for <code>soundex</code>.</p>
<pre><code class="lang-perl">my $result = sdx $x
# or in a pipeline:
@list |> map sdx |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sec">
<h3><a class="doc-anchor" href="#doc-sec">#</a> <code>sec</code></h3>
<p><code>sec</code> returns the secant (1/cos) of an angle in radians.</p>
<pre><code class="lang-perl">p sec(0) # 1.0
</code></pre>
</article>
<article class="doc-entry" id="doc-second">
<h3><a class="doc-anchor" href="#doc-second">#</a> <code>second</code></h3>
<p><code>second</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = second $x
# or in a pipeline:
@list |> map second |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-second-arg">
<h3><a class="doc-anchor" href="#doc-second-arg">#</a> <code>second_arg</code></h3>
<p><code>second_arg</code> — functional primitives builtin.</p>
<pre><code class="lang-perl">my $result = second_arg $x
# or in a pipeline:
@list |> map second_arg |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-second-elem">
<h3><a class="doc-anchor" href="#doc-second-elem">#</a> <code>second_elem</code></h3>
<p><code>second_elem</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = second_elem $x
# or in a pipeline:
@list |> map second_elem |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-seconds-to-days">
<h3><a class="doc-anchor" href="#doc-seconds-to-days">#</a> <code>seconds_to_days</code></h3>
<p><code>seconds_to_days</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = seconds_to_days $input
</code></pre>
</article>
<article class="doc-entry" id="doc-seconds-to-hours">
<h3><a class="doc-anchor" href="#doc-seconds-to-hours">#</a> <code>seconds_to_hours</code></h3>
<p><code>seconds_to_hours</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = seconds_to_hours $input
</code></pre>
</article>
<article class="doc-entry" id="doc-seconds-to-minutes">
<h3><a class="doc-anchor" href="#doc-seconds-to-minutes">#</a> <code>seconds_to_minutes</code></h3>
<p><code>seconds_to_minutes</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = seconds_to_minutes $input
</code></pre>
</article>
<article class="doc-entry" id="doc-sectarea">
<h3><a class="doc-anchor" href="#doc-sectarea">#</a> <code>sectarea</code></h3>
<p><code>sectarea</code> — geometry (extended) builtin. Alias for <code>sector_area</code>.</p>
<pre><code class="lang-perl">my $result = sectarea $x
# or in a pipeline:
@list |> map sectarea |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sector-area">
<h3><a class="doc-anchor" href="#doc-sector-area">#</a> <code>sector_area</code></h3>
<p><code>sector_area($radius, $theta)</code> — computes the area of a circular sector. Theta is the central angle in radians. Returns <code>0.5 * r² * theta</code>.</p>
<pre><code class="lang-perl">p sector_area(10, 3.14159) # ~157 (half circle)
p sector_area(5, 1.57) # ~19.6
</code></pre>
</article>
<article class="doc-entry" id="doc-selu">
<h3><a class="doc-anchor" href="#doc-selu">#</a> <code>selu</code></h3>
<p><code>selu</code> applies the Scaled ELU with fixed lambda=1.0507, alpha=1.6733 for self-normalizing networks.</p>
<pre><code class="lang-perl">p selu(1) # 1.0507
p selu(-1) # -1.1113
</code></pre>
</article>
<article class="doc-entry" id="doc-semctl">
<h3><a class="doc-anchor" href="#doc-semctl">#</a> <code>semctl</code></h3>
<p><code>semctl</code> — sysv ipc builtin.</p>
<pre><code class="lang-perl">my $result = semctl $x
# or in a pipeline:
@list |> map semctl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-semget">
<h3><a class="doc-anchor" href="#doc-semget">#</a> <code>semget</code></h3>
<p><code>semget</code> — sysv ipc builtin.</p>
<pre><code class="lang-perl">my $result = semget $x
# or in a pipeline:
@list |> map semget |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-semop">
<h3><a class="doc-anchor" href="#doc-semop">#</a> <code>semop</code></h3>
<p><code>semop</code> — sysv ipc builtin.</p>
<pre><code class="lang-perl">my $result = semop $x
# or in a pipeline:
@list |> map semop |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sentence-case">
<h3><a class="doc-anchor" href="#doc-sentence-case">#</a> <code>sentence_case</code></h3>
<p><code>sentence_case</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = sentence_case $x
# or in a pipeline:
@list |> map sentence_case |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-seq">
<h3><a class="doc-anchor" href="#doc-seq">#</a> <code>seq</code></h3>
<p><code>seq</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = seq $x
# or in a pipeline:
@list |> map seq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-seq-fn">
<h3><a class="doc-anchor" href="#doc-seq-fn">#</a> <code>seq_fn</code></h3>
<p><code>seq_fn</code> — generate a numeric sequence from, to, by. Like R's seq().</p>
<pre><code class="lang-perl">my @s = @{seq_fn(1, 10, 2)} # [1,3,5,7,9]
my @r = @{seq_fn(5, 1, -1)} # [5,4,3,2,1]
</code></pre>
</article>
<article class="doc-entry" id="doc-setgrent">
<h3><a class="doc-anchor" href="#doc-setgrent">#</a> <code>setgrent</code></h3>
<p><code>setgrent</code> — posix metadata builtin.</p>
<pre><code class="lang-perl">my $result = setgrent $x
# or in a pipeline:
@list |> map setgrent |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sethostent">
<h3><a class="doc-anchor" href="#doc-sethostent">#</a> <code>sethostent</code></h3>
<p><code>sethostent</code> — posix metadata builtin.</p>
<pre><code class="lang-perl">my $result = sethostent $x
# or in a pipeline:
@list |> map sethostent |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-setnetent">
<h3><a class="doc-anchor" href="#doc-setnetent">#</a> <code>setnetent</code></h3>
<p><code>setnetent</code> — posix metadata builtin.</p>
<pre><code class="lang-perl">my $result = setnetent $x
# or in a pipeline:
@list |> map setnetent |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-setprotoent">
<h3><a class="doc-anchor" href="#doc-setprotoent">#</a> <code>setprotoent</code></h3>
<p><code>setprotoent</code> — posix metadata builtin.</p>
<pre><code class="lang-perl">my $result = setprotoent $x
# or in a pipeline:
@list |> map setprotoent |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-setpwent">
<h3><a class="doc-anchor" href="#doc-setpwent">#</a> <code>setpwent</code></h3>
<p><code>setpwent</code> — posix metadata builtin.</p>
<pre><code class="lang-perl">my $result = setpwent $x
# or in a pipeline:
@list |> map setpwent |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-setservent">
<h3><a class="doc-anchor" href="#doc-setservent">#</a> <code>setservent</code></h3>
<p><code>setservent</code> — posix metadata builtin.</p>
<pre><code class="lang-perl">my $result = setservent $x
# or in a pipeline:
@list |> map setservent |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sgnum">
<h3><a class="doc-anchor" href="#doc-sgnum">#</a> <code>sgnum</code></h3>
<p><code>sgnum</code> — extended stdlib builtin. Alias for <code>signum_of</code>.</p>
<pre><code class="lang-perl">my $result = sgnum $x
# or in a pipeline:
@list |> map sgnum |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-shapiro">
<h3><a class="doc-anchor" href="#doc-shapiro">#</a> <code>shapiro</code></h3>
<p><code>shapiro_test</code> (alias <code>shapiro</code>) — Shapiro-Wilk normality test. Returns W statistic (close to 1 = normal). Like R's shapiro.test().</p>
<pre><code class="lang-perl">p shapiro([rnorm(100)]) # W ≈ 0.99 for normal data
p shapiro([1,1,1,2,10]) # W < 0.9 for non-normal
</code></pre>
</article>
<article class="doc-entry" id="doc-sharpe">
<h3><a class="doc-anchor" href="#doc-sharpe">#</a> <code>sharpe</code></h3>
<p><code>sharpe_ratio(\@returns, $risk_free_rate)</code> (alias <code>sharpe</code>) — computes the Sharpe ratio measuring risk-adjusted returns. Higher is better. Returns (mean_return - rf) / stddev.</p>
<pre><code class="lang-perl">my @returns = (0.05, -0.02, 0.08, 0.03)
p sharpe(\@returns, 0.02) # risk-adjusted performance
</code></pre>
</article>
<article class="doc-entry" id="doc-shift-left">
<h3><a class="doc-anchor" href="#doc-shift-left">#</a> <code>shift_left</code></h3>
<p><code>shift_left</code> — bit ops builtin.</p>
<pre><code class="lang-perl">my $result = shift_left $x
# or in a pipeline:
@list |> map shift_left |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-shift-right">
<h3><a class="doc-anchor" href="#doc-shift-right">#</a> <code>shift_right</code></h3>
<p><code>shift_right</code> — bit ops builtin.</p>
<pre><code class="lang-perl">my $result = shift_right $x
# or in a pipeline:
@list |> map shift_right |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-shl">
<h3><a class="doc-anchor" href="#doc-shl">#</a> <code>shl</code></h3>
<p><code>shl</code> — bit ops builtin. Alias for <code>shift_left</code>.</p>
<pre><code class="lang-perl">my $result = shl $x
# or in a pipeline:
@list |> map shl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-shmctl">
<h3><a class="doc-anchor" href="#doc-shmctl">#</a> <code>shmctl</code></h3>
<p><code>shmctl</code> — sysv ipc builtin.</p>
<pre><code class="lang-perl">my $result = shmctl $x
# or in a pipeline:
@list |> map shmctl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-shmget">
<h3><a class="doc-anchor" href="#doc-shmget">#</a> <code>shmget</code></h3>
<p><code>shmget</code> — sysv ipc builtin.</p>
<pre><code class="lang-perl">my $result = shmget $x
# or in a pipeline:
@list |> map shmget |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-shmread">
<h3><a class="doc-anchor" href="#doc-shmread">#</a> <code>shmread</code></h3>
<p><code>shmread</code> — sysv ipc builtin.</p>
<pre><code class="lang-perl">my $result = shmread $x
# or in a pipeline:
@list |> map shmread |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-shmwrite">
<h3><a class="doc-anchor" href="#doc-shmwrite">#</a> <code>shmwrite</code></h3>
<p><code>shmwrite</code> — sysv ipc builtin.</p>
<pre><code class="lang-perl">my $result = shmwrite $x
# or in a pipeline:
@list |> map shmwrite |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-short-id">
<h3><a class="doc-anchor" href="#doc-short-id">#</a> <code>short_id</code></h3>
<p><code>short_id</code> — id helpers builtin.</p>
<pre><code class="lang-perl">my $result = short_id $x
# or in a pipeline:
@list |> map short_id |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-shorten">
<h3><a class="doc-anchor" href="#doc-shorten">#</a> <code>shorten</code></h3>
<p><code>shorten</code> — trivial string ops builtin. Alias for <code>truncate_at</code>.</p>
<pre><code class="lang-perl">my $result = shorten $x
# or in a pipeline:
@list |> map shorten |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-shortest">
<h3><a class="doc-anchor" href="#doc-shortest">#</a> <code>shortest</code></h3>
<p><code>shortest</code> — collection (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = shortest $x
# or in a pipeline:
@list |> map shortest |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-shortest-path-bfs">
<h3><a class="doc-anchor" href="#doc-shortest-path-bfs">#</a> <code>shortest_path_bfs</code></h3>
<p><code>shortest_path_bfs</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = shortest_path_bfs $x
# or in a pipeline:
@list |> map shortest_path_bfs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-shr">
<h3><a class="doc-anchor" href="#doc-shr">#</a> <code>shr</code></h3>
<p><code>shr</code> — bit ops builtin. Alias for <code>shift_right</code>.</p>
<pre><code class="lang-perl">my $result = shr $x
# or in a pipeline:
@list |> map shr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-shuf">
<h3><a class="doc-anchor" href="#doc-shuf">#</a> <code>shuf</code></h3>
<p><code>shuf</code> — extended stdlib builtin. Alias for <code>shuffle_arr</code>.</p>
<pre><code class="lang-perl">my $result = shuf $x
# or in a pipeline:
@list |> map shuf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-shuffle-arr">
<h3><a class="doc-anchor" href="#doc-shuffle-arr">#</a> <code>shuffle_arr</code></h3>
<p><code>shuffle_arr</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = shuffle_arr $x
# or in a pipeline:
@list |> map shuffle_arr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-shuffle-chars">
<h3><a class="doc-anchor" href="#doc-shuffle-chars">#</a> <code>shuffle_chars</code></h3>
<p><code>shuffle_chars</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = shuffle_chars $x
# or in a pipeline:
@list |> map shuffle_chars |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-shuffled">
<h3><a class="doc-anchor" href="#doc-shuffled">#</a> <code>shuffled</code></h3>
<p><code>shuffled</code> — functional / iterator builtin.</p>
<pre><code class="lang-perl">my $result = shuffled $x
# or in a pipeline:
@list |> map shuffled |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sierp">
<h3><a class="doc-anchor" href="#doc-sierp">#</a> <code>sierp</code></h3>
<p><code>sierp</code> — algorithms / puzzles builtin. Alias for <code>sierpinski</code>.</p>
<pre><code class="lang-perl">my $result = sierp $x
# or in a pipeline:
@list |> map sierp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sierpinski">
<h3><a class="doc-anchor" href="#doc-sierpinski">#</a> <code>sierpinski</code></h3>
<p><code>sierpinski</code> — algorithms / puzzles builtin.</p>
<pre><code class="lang-perl">my $result = sierpinski $x
# or in a pipeline:
@list |> map sierpinski |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sieve">
<h3><a class="doc-anchor" href="#doc-sieve">#</a> <code>sieve</code></h3>
<p><code>sieve</code> — number theory / primes builtin. Alias for <code>primes_up_to</code>.</p>
<pre><code class="lang-perl">my $result = sieve $x
# or in a pipeline:
@list |> map sieve |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sigma-sb">
<h3><a class="doc-anchor" href="#doc-sigma-sb">#</a> <code>sigma_sb</code></h3>
<p><code>sigma_sb</code> — physics constants builtin. Alias for <code>stefan_boltzmann_constant</code>.</p>
<pre><code class="lang-perl">my $result = sigma_sb $x
# or in a pipeline:
@list |> map sigma_sb |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sigmoid">
<h3><a class="doc-anchor" href="#doc-sigmoid">#</a> <code>sigmoid</code></h3>
<p><code>sigmoid</code> — math functions builtin.</p>
<pre><code class="lang-perl">my $result = sigmoid $x
# or in a pipeline:
@list |> map sigmoid |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sign">
<h3><a class="doc-anchor" href="#doc-sign">#</a> <code>sign</code></h3>
<p><code>sign</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = sign $x
# or in a pipeline:
@list |> map sign |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-signal-name">
<h3><a class="doc-anchor" href="#doc-signal-name">#</a> <code>signal_name</code></h3>
<p><code>signal_name</code> — more process / system builtin.</p>
<pre><code class="lang-perl">my $result = signal_name $x
# or in a pipeline:
@list |> map signal_name |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-signum">
<h3><a class="doc-anchor" href="#doc-signum">#</a> <code>signum</code></h3>
<p><code>signum</code> — math functions builtin.</p>
<pre><code class="lang-perl">my $result = signum $x
# or in a pipeline:
@list |> map signum |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-signum-of">
<h3><a class="doc-anchor" href="#doc-signum-of">#</a> <code>signum_of</code></h3>
<p><code>signum_of</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = signum_of $x
# or in a pipeline:
@list |> map signum_of |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-silu">
<h3><a class="doc-anchor" href="#doc-silu">#</a> <code>silu</code></h3>
<p><code>silu</code> (alias <code>swish</code>) applies SiLU/Swish: x·sigmoid(x). Smooth approximation to ReLU.</p>
<pre><code class="lang-perl">p silu(1) # 0.7311
p swish(-2) # -0.2384
</code></pre>
</article>
<article class="doc-entry" id="doc-silver">
<h3><a class="doc-anchor" href="#doc-silver">#</a> <code>silver</code></h3>
<p><code>silver_ratio</code> (alias <code>silver</code>) — δS = 1 + √2 ≈ 2.414. Related to Pell numbers.</p>
<pre><code class="lang-perl">p silver # 2.414213562373095
</code></pre>
</article>
<article class="doc-entry" id="doc-sim">
<h3><a class="doc-anchor" href="#doc-sim">#</a> <code>sim</code></h3>
<p><code>sim</code> — extended stdlib builtin. Alias for <code>similarity</code>.</p>
<pre><code class="lang-perl">my $result = sim $x
# or in a pipeline:
@list |> map sim |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-similarity">
<h3><a class="doc-anchor" href="#doc-similarity">#</a> <code>similarity</code></h3>
<p><code>similarity</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = similarity $x
# or in a pipeline:
@list |> map similarity |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-simple-interest">
<h3><a class="doc-anchor" href="#doc-simple-interest">#</a> <code>simple_interest</code></h3>
<p><code>simple_interest</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = simple_interest $x
# or in a pipeline:
@list |> map simple_interest |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-simps">
<h3><a class="doc-anchor" href="#doc-simps">#</a> <code>simps</code></h3>
<p><code>simpson</code> (alias <code>simps</code>) integrates evenly-spaced samples using Simpson's rule. More accurate than trapz for smooth functions.</p>
<pre><code class="lang-perl">my @y = map { sin($_ * 0.01) } 0..314
p simps(\@y, 0.01) # ≈ 2.0
</code></pre>
</article>
<article class="doc-entry" id="doc-sinc">
<h3><a class="doc-anchor" href="#doc-sinc">#</a> <code>sinc</code></h3>
<p><code>sinc</code> returns the unnormalized sinc function: sin(x)/x, with sinc(0)=1.</p>
<pre><code class="lang-perl">p sinc(0) # 1.0
p sinc(3.14159) # ≈ 0
</code></pre>
</article>
<article class="doc-entry" id="doc-single-quote">
<h3><a class="doc-anchor" href="#doc-single-quote">#</a> <code>single_quote</code></h3>
<p><code>single_quote</code> — string quote / escape builtin.</p>
<pre><code class="lang-perl">my $result = single_quote $x
# or in a pipeline:
@list |> map single_quote |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sinh">
<h3><a class="doc-anchor" href="#doc-sinh">#</a> <code>sinh</code></h3>
<p><code>sinh</code> — trig / math (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = sinh $x
# or in a pipeline:
@list |> map sinh |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-siphash-keyed">
<h3><a class="doc-anchor" href="#doc-siphash-keyed">#</a> <code>siphash_keyed</code></h3>
<p><code>siphash_keyed</code> computes SipHash-2-4 with a custom 128-bit key (two 64-bit integers). The key should be random per application to prevent collision attacks.</p>
<pre><code class="lang-perl">p siphash_keyed("data", 0x123456789, 0xabcdef012) # keyed hash
</code></pre>
</article>
<article class="doc-entry" id="doc-size">
<h3><a class="doc-anchor" href="#doc-size">#</a> <code>size</code></h3>
<p><code>size</code> returns the byte size of a file on disk — equivalent to Perl's <code>-s FILE</code> file test. With no arguments, it operates on <code>$_</code>; with one argument, it stats the given path; with multiple arguments (or a flattened list), it returns an array of sizes. Paths that can't be stat'd return <code>undef</code>. This is a stryke extension that makes pipelines over filenames concise.</p>
<pre><code class="lang-perl">p size "Cargo.toml" # 2013
f |> map +{ $_ => size } |> tj |> p # [{name => bytes}, ...]
f |> filter { size > 1024 } |> e p # files larger than 1 KiB
</code></pre>
</article>
<article class="doc-entry" id="doc-skew">
<h3><a class="doc-anchor" href="#doc-skew">#</a> <code>skew</code></h3>
<p><code>skew</code> — math / numeric (uncategorized batch) builtin. Alias for <code>skewness</code>.</p>
<pre><code class="lang-perl">my $result = skew $x
# or in a pipeline:
@list |> map skew |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-skewness">
<h3><a class="doc-anchor" href="#doc-skewness">#</a> <code>skewness</code></h3>
<p><code>skewness</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = skewness $x
# or in a pipeline:
@list |> map skewness |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-skip-while">
<h3><a class="doc-anchor" href="#doc-skip-while">#</a> <code>skip_while</code></h3>
<p><code>skip_while { COND } LIST</code> — skip leading elements while the predicate is true (alias for <code>drop_while</code>).</p>
<p>Behavior is identical to <code>drop_while</code>: once the predicate returns false, that element and all subsequent elements are emitted. The <code>skip_while</code> name is provided for users coming from Rust or Kotlin where this is the conventional name. Both compile to the same streaming operation internally.</p>
<pre><code class="lang-perl">1..10 |> skip_while { $_ < 5 } |> e p # 5 6 7 8 9 10
@sorted |> skip_while { $_ le "m" } |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-sla">
<h3><a class="doc-anchor" href="#doc-sla">#</a> <code>sla</code></h3>
<p><code>sla</code> — python/ruby stdlib builtin. Alias for <code>slice_arr</code>.</p>
<pre><code class="lang-perl">my $result = sla $x
# or in a pipeline:
@list |> map sla |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-slca">
<h3><a class="doc-anchor" href="#doc-slca">#</a> <code>slca</code></h3>
<p><code>slca</code> — additional missing stdlib functions builtin. Alias for <code>slice_after</code>.</p>
<pre><code class="lang-perl">my $result = slca $x
# or in a pipeline:
@list |> map slca |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-slcb">
<h3><a class="doc-anchor" href="#doc-slcb">#</a> <code>slcb</code></h3>
<p><code>slcb</code> — additional missing stdlib functions builtin. Alias for <code>slice_before</code>.</p>
<pre><code class="lang-perl">my $result = slcb $x
# or in a pipeline:
@list |> map slcb |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-slcw">
<h3><a class="doc-anchor" href="#doc-slcw">#</a> <code>slcw</code></h3>
<p><code>slcw</code> — additional missing stdlib functions builtin. Alias for <code>slice_when</code>.</p>
<pre><code class="lang-perl">my $result = slcw $x
# or in a pipeline:
@list |> map slcw |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-slice-after">
<h3><a class="doc-anchor" href="#doc-slice-after">#</a> <code>slice_after</code></h3>
<p><code>slice_after</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = slice_after $x
# or in a pipeline:
@list |> map slice_after |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-slice-arr">
<h3><a class="doc-anchor" href="#doc-slice-arr">#</a> <code>slice_arr</code></h3>
<p><code>slice_arr</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = slice_arr $x
# or in a pipeline:
@list |> map slice_arr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-slice-before">
<h3><a class="doc-anchor" href="#doc-slice-before">#</a> <code>slice_before</code></h3>
<p><code>slice_before</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = slice_before $x
# or in a pipeline:
@list |> map slice_before |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-slice-when">
<h3><a class="doc-anchor" href="#doc-slice-when">#</a> <code>slice_when</code></h3>
<p><code>slice_when</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = slice_when $x
# or in a pipeline:
@list |> map slice_when |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sliding-pairs">
<h3><a class="doc-anchor" href="#doc-sliding-pairs">#</a> <code>sliding_pairs</code></h3>
<p><code>sliding_pairs</code> — collection more builtin.</p>
<pre><code class="lang-perl">my $result = sliding_pairs $x
# or in a pipeline:
@list |> map sliding_pairs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sliding-window">
<h3><a class="doc-anchor" href="#doc-sliding-window">#</a> <code>sliding_window</code></h3>
<p><code>sliding_window</code> — functional / iterator builtin.</p>
<pre><code class="lang-perl">my $result = sliding_window $x
# or in a pipeline:
@list |> map sliding_window |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-slope">
<h3><a class="doc-anchor" href="#doc-slope">#</a> <code>slope</code></h3>
<p><code>slope</code> — geometry / physics builtin.</p>
<pre><code class="lang-perl">my $result = slope $x
# or in a pipeline:
@list |> map slope |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-slug">
<h3><a class="doc-anchor" href="#doc-slug">#</a> <code>slug</code></h3>
<p><code>slug</code> — extended stdlib builtin. Alias for <code>slugify</code>.</p>
<pre><code class="lang-perl">my $result = slug $x
# or in a pipeline:
@list |> map slug |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-slugify">
<h3><a class="doc-anchor" href="#doc-slugify">#</a> <code>slugify</code></h3>
<p><code>slugify</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = slugify $x
# or in a pipeline:
@list |> map slugify |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-smap">
<h3><a class="doc-anchor" href="#doc-smap">#</a> <code>smap</code></h3>
<p><code>smap</code> — python/ruby stdlib builtin. Alias for <code>starmap</code>.</p>
<pre><code class="lang-perl">my $result = smap $x
# or in a pipeline:
@list |> map smap |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-smoothstep">
<h3><a class="doc-anchor" href="#doc-smoothstep">#</a> <code>smoothstep</code></h3>
<p><code>smoothstep($edge0, $edge1, $x)</code> — smooth Hermite interpolation. Returns 0 if x ≤ edge0, 1 if x ≥ edge1, otherwise smooth S-curve. Great for animations.</p>
<pre><code class="lang-perl">p smoothstep(0, 1, 0.5) # 0.5 (but with smooth acceleration/deceleration)
p smoothstep(10, 20, 15) # 0.5
</code></pre>
</article>
<article class="doc-entry" id="doc-smst">
<h3><a class="doc-anchor" href="#doc-smst">#</a> <code>smst</code></h3>
<p><code>smst</code> — extended stdlib builtin. Alias for <code>smoothstep</code>.</p>
<pre><code class="lang-perl">my $result = smst $x
# or in a pipeline:
@list |> map smst |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-snake-to-camel">
<h3><a class="doc-anchor" href="#doc-snake-to-camel">#</a> <code>snake_to_camel</code></h3>
<p><code>snake_to_camel</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = snake_to_camel $input
</code></pre>
</article>
<article class="doc-entry" id="doc-snd">
<h3><a class="doc-anchor" href="#doc-snd">#</a> <code>snd</code></h3>
<p><code>snd</code> — algebraic match builtin. Alias for <code>second</code>.</p>
<pre><code class="lang-perl">my $result = snd $x
# or in a pipeline:
@list |> map snd |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-snell">
<h3><a class="doc-anchor" href="#doc-snell">#</a> <code>snell</code></h3>
<p><code>snells_law($n1, $n2, $theta1)</code> (alias <code>snell</code>) — refraction angle using Snell's law. Angles in degrees. Returns undef for total internal reflection.</p>
<pre><code class="lang-perl">p snell(1, 1.5, 30) # ~19.5° (air to glass)
p snell(1.5, 1, 45) # undef (total internal reflection)
</code></pre>
</article>
<article class="doc-entry" id="doc-socketpair">
<h3><a class="doc-anchor" href="#doc-socketpair">#</a> <code>socketpair</code></h3>
<p><code>socketpair</code> — socket builtin.</p>
<pre><code class="lang-perl">my $result = socketpair $x
# or in a pipeline:
@list |> map socketpair |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sockets">
<h3><a class="doc-anchor" href="#doc-sockets">#</a> <code>sockets</code></h3>
<p><code>sockets</code> — filesystem extensions builtin.</p>
<pre><code class="lang-perl">my $result = sockets $x
# or in a pipeline:
@list |> map sockets |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sod">
<h3><a class="doc-anchor" href="#doc-sod">#</a> <code>sod</code></h3>
<p><code>sod</code> — extended stdlib builtin. Alias for <code>start_of_day</code>.</p>
<pre><code class="lang-perl">my $result = sod $x
# or in a pipeline:
@list |> map sod |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-softmax">
<h3><a class="doc-anchor" href="#doc-softmax">#</a> <code>softmax</code></h3>
<p><code>softmax</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = softmax $x
# or in a pipeline:
@list |> map softmax |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-softplus">
<h3><a class="doc-anchor" href="#doc-softplus">#</a> <code>softplus</code></h3>
<p><code>softplus</code> applies the Softplus activation: ln(1 + e^x). Smooth approximation to ReLU.</p>
<pre><code class="lang-perl">p softplus(0) # 0.6931 (ln 2)
p softplus(10) # ≈ 10
</code></pre>
</article>
<article class="doc-entry" id="doc-soh">
<h3><a class="doc-anchor" href="#doc-soh">#</a> <code>soh</code></h3>
<p><code>soh</code> — extended stdlib builtin. Alias for <code>start_of_hour</code>.</p>
<pre><code class="lang-perl">my $result = soh $x
# or in a pipeline:
@list |> map soh |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sol">
<h3><a class="doc-anchor" href="#doc-sol">#</a> <code>sol</code></h3>
<p><code>sol</code> — constants builtin.</p>
<pre><code class="lang-perl">my $result = sol $x
# or in a pipeline:
@list |> map sol |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sole">
<h3><a class="doc-anchor" href="#doc-sole">#</a> <code>sole</code></h3>
<p><code>sole</code> — ruby enumerable extras builtin.</p>
<pre><code class="lang-perl">my $result = sole $x
# or in a pipeline:
@list |> map sole |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-som">
<h3><a class="doc-anchor" href="#doc-som">#</a> <code>som</code></h3>
<p><code>som</code> — extended stdlib builtin. Alias for <code>start_of_minute</code>.</p>
<pre><code class="lang-perl">my $result = som $x
# or in a pipeline:
@list |> map som |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-some">
<h3><a class="doc-anchor" href="#doc-some">#</a> <code>some</code></h3>
<p><code>some</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = some $x
# or in a pipeline:
@list |> map some |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sort-by">
<h3><a class="doc-anchor" href="#doc-sort-by">#</a> <code>sort_by</code></h3>
<p><code>sort_by</code> — functional / iterator builtin.</p>
<pre><code class="lang-perl">my $result = sort_by $x
# or in a pipeline:
@list |> map sort_by |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sort-on">
<h3><a class="doc-anchor" href="#doc-sort-on">#</a> <code>sort_on</code></h3>
<p><code>sort_on</code> — haskell list functions builtin.</p>
<pre><code class="lang-perl">my $result = sort_on $x
# or in a pipeline:
@list |> map sort_on |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sort-words">
<h3><a class="doc-anchor" href="#doc-sort-words">#</a> <code>sort_words</code></h3>
<p><code>sort_words</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = sort_words $x
# or in a pipeline:
@list |> map sort_words |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sorted">
<h3><a class="doc-anchor" href="#doc-sorted">#</a> <code>sorted</code></h3>
<p><code>sorted</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = sorted $x
# or in a pipeline:
@list |> map sorted |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sorted-by-length">
<h3><a class="doc-anchor" href="#doc-sorted-by-length">#</a> <code>sorted_by_length</code></h3>
<p><code>sorted_by_length</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = sorted_by_length $x
# or in a pipeline:
@list |> map sorted_by_length |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sorted-desc">
<h3><a class="doc-anchor" href="#doc-sorted-desc">#</a> <code>sorted_desc</code></h3>
<p><code>sorted_desc</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = sorted_desc $x
# or in a pipeline:
@list |> map sorted_desc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sorted-nums">
<h3><a class="doc-anchor" href="#doc-sorted-nums">#</a> <code>sorted_nums</code></h3>
<p><code>sorted_nums</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = sorted_nums $x
# or in a pipeline:
@list |> map sorted_nums |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sortino">
<h3><a class="doc-anchor" href="#doc-sortino">#</a> <code>sortino</code></h3>
<p><code>sortino_ratio(\@returns, $target)</code> (alias <code>sortino</code>) — computes the Sortino ratio, similar to Sharpe but only penalizes downside volatility. Better for asymmetric return distributions.</p>
<pre><code class="lang-perl">my @returns = (0.05, -0.02, 0.08, -0.01)
p sortino(\@returns, 0.0) # penalizes only negative returns
</code></pre>
</article>
<article class="doc-entry" id="doc-sortw">
<h3><a class="doc-anchor" href="#doc-sortw">#</a> <code>sortw</code></h3>
<p><code>sortw</code> — string processing (uncategorized batch) builtin. Alias for <code>sort_words</code>.</p>
<pre><code class="lang-perl">my $result = sortw $x
# or in a pipeline:
@list |> map sortw |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-soundex">
<h3><a class="doc-anchor" href="#doc-soundex">#</a> <code>soundex</code></h3>
<p><code>soundex</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = soundex $x
# or in a pipeline:
@list |> map soundex |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-spaceship">
<h3><a class="doc-anchor" href="#doc-spaceship">#</a> <code>spaceship</code></h3>
<p><code>spaceship</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = spaceship $x
# or in a pipeline:
@list |> map spaceship |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-span">
<h3><a class="doc-anchor" href="#doc-span">#</a> <code>span</code></h3>
<p><code>span</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = span $x
# or in a pipeline:
@list |> map span |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-span-fn">
<h3><a class="doc-anchor" href="#doc-span-fn">#</a> <code>span_fn</code></h3>
<p><code>span_fn</code> — haskell list functions builtin.</p>
<pre><code class="lang-perl">my $result = span_fn $x
# or in a pipeline:
@list |> map span_fn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-spanf">
<h3><a class="doc-anchor" href="#doc-spanf">#</a> <code>spanf</code></h3>
<p><code>spanf</code> — haskell list functions builtin. Alias for <code>span_fn</code>.</p>
<pre><code class="lang-perl">my $result = spanf $x
# or in a pipeline:
@list |> map spanf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-spat">
<h3><a class="doc-anchor" href="#doc-spat">#</a> <code>spat</code></h3>
<p><code>spat</code> — algebraic match builtin. Alias for <code>split_at</code>.</p>
<pre><code class="lang-perl">my $result = spat $x
# or in a pipeline:
@list |> map spat |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-spbfs">
<h3><a class="doc-anchor" href="#doc-spbfs">#</a> <code>spbfs</code></h3>
<p><code>spbfs</code> — extended stdlib builtin. Alias for <code>shortest_path_bfs</code>.</p>
<pre><code class="lang-perl">my $result = spbfs $x
# or in a pipeline:
@list |> map spbfs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-spearman">
<h3><a class="doc-anchor" href="#doc-spearman">#</a> <code>spearman</code></h3>
<p><code>spearman_correlation(\@x, \@y)</code> (alias <code>spearman</code>) — computes Spearman's rank correlation coefficient between two datasets. Measures monotonic relationships, robust to outliers. Returns a value from -1 to 1.</p>
<pre><code class="lang-perl">my @x = (1, 2, 3, 4, 5)
my @y = (5, 6, 7, 8, 7)
p spearman(\@x, \@y) # high positive correlation
</code></pre>
</article>
<article class="doc-entry" id="doc-spectro">
<h3><a class="doc-anchor" href="#doc-spectro">#</a> <code>spectro</code></h3>
<p><code>spectro</code> — dsp / signal (extended) builtin. Alias for <code>spectrogram</code>.</p>
<pre><code class="lang-perl">my $result = spectro $x
# or in a pipeline:
@list |> map spectro |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-spectrogram">
<h3><a class="doc-anchor" href="#doc-spectrogram">#</a> <code>spectrogram</code></h3>
<p><code>spectrogram(\@signal, $window_size, $hop_size)</code> (alias <code>stft</code>) — computes Short-Time Fourier Transform. Returns a 2D arrayref where each row is the spectrum of a windowed segment. Useful for time-frequency analysis.</p>
<pre><code class="lang-perl">my $spec = stft(\@audio, 1024, 512)
# $spec->[t][f] is magnitude at time t, frequency f
</code></pre>
</article>
<article class="doc-entry" id="doc-speed-distance-time">
<h3><a class="doc-anchor" href="#doc-speed-distance-time">#</a> <code>speed_distance_time</code></h3>
<p><code>speed_distance_time</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = speed_distance_time $x
# or in a pipeline:
@list |> map speed_distance_time |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-speed-of-light">
<h3><a class="doc-anchor" href="#doc-speed-of-light">#</a> <code>speed_of_light</code></h3>
<p><code>speed_of_light</code> — math / physics constants builtin.</p>
<pre><code class="lang-perl">my $result = speed_of_light $x
# or in a pipeline:
@list |> map speed_of_light |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sphere-surface">
<h3><a class="doc-anchor" href="#doc-sphere-surface">#</a> <code>sphere_surface</code></h3>
<p><code>sphere_surface</code> — geometry / physics builtin.</p>
<pre><code class="lang-perl">my $result = sphere_surface $x
# or in a pipeline:
@list |> map sphere_surface |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sphere-volume">
<h3><a class="doc-anchor" href="#doc-sphere-volume">#</a> <code>sphere_volume</code></h3>
<p><code>sphere_volume</code> — geometry / physics builtin.</p>
<pre><code class="lang-perl">my $result = sphere_volume $x
# or in a pipeline:
@list |> map sphere_volume |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sphsurf">
<h3><a class="doc-anchor" href="#doc-sphsurf">#</a> <code>sphsurf</code></h3>
<p><code>sphsurf</code> — geometry / physics builtin. Alias for <code>sphere_surface</code>.</p>
<pre><code class="lang-perl">my $result = sphsurf $x
# or in a pipeline:
@list |> map sphsurf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sphvol">
<h3><a class="doc-anchor" href="#doc-sphvol">#</a> <code>sphvol</code></h3>
<p><code>sphvol</code> — geometry / physics builtin. Alias for <code>sphere_volume</code>.</p>
<pre><code class="lang-perl">my $result = sphvol $x
# or in a pipeline:
@list |> map sphvol |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-spinner-start">
<h3><a class="doc-anchor" href="#doc-spinner-start">#</a> <code>spinner_start</code></h3>
<p><code>spinner_start</code> — pipeline / string helpers builtin.</p>
<pre><code class="lang-perl">my $result = spinner_start $x
# or in a pipeline:
@list |> map spinner_start |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-spinner-stop">
<h3><a class="doc-anchor" href="#doc-spinner-stop">#</a> <code>spinner_stop</code></h3>
<p><code>spinner_stop</code> — pipeline / string helpers builtin.</p>
<pre><code class="lang-perl">my $result = spinner_stop $x
# or in a pipeline:
@list |> map spinner_stop |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-split-at">
<h3><a class="doc-anchor" href="#doc-split-at">#</a> <code>split_at</code></h3>
<p><code>split_at</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = split_at $x
# or in a pipeline:
@list |> map split_at |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-split-on">
<h3><a class="doc-anchor" href="#doc-split-on">#</a> <code>split_on</code></h3>
<p><code>split_on</code> — go/general functional utilities builtin.</p>
<pre><code class="lang-perl">my $result = split_on $x
# or in a pipeline:
@list |> map split_on |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-split-regex">
<h3><a class="doc-anchor" href="#doc-split-regex">#</a> <code>split_regex</code></h3>
<p><code>split_regex</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = split_regex $x
# or in a pipeline:
@list |> map split_regex |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-split-with">
<h3><a class="doc-anchor" href="#doc-split-with">#</a> <code>split_with</code></h3>
<p><code>split_with</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = split_with $x
# or in a pipeline:
@list |> map split_with |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-splre">
<h3><a class="doc-anchor" href="#doc-splre">#</a> <code>splre</code></h3>
<p><code>splre</code> — extended stdlib builtin. Alias for <code>split_regex</code>.</p>
<pre><code class="lang-perl">my $result = splre $x
# or in a pipeline:
@list |> map splre |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-spon">
<h3><a class="doc-anchor" href="#doc-spon">#</a> <code>spon</code></h3>
<p><code>spon</code> — go/general functional utilities builtin. Alias for <code>split_on</code>.</p>
<pre><code class="lang-perl">my $result = spon $x
# or in a pipeline:
@list |> map spon |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-spring-energy">
<h3><a class="doc-anchor" href="#doc-spring-energy">#</a> <code>spring_energy</code></h3>
<p><code>spring_energy</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = spring_energy $x
# or in a pipeline:
@list |> map spring_energy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-spring-force">
<h3><a class="doc-anchor" href="#doc-spring-force">#</a> <code>spring_force</code></h3>
<p><code>spring_force</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = spring_force $x
# or in a pipeline:
@list |> map spring_force |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-springpe">
<h3><a class="doc-anchor" href="#doc-springpe">#</a> <code>springpe</code></h3>
<p><code>springpe</code> — physics formulas builtin. Alias for <code>spring_energy</code>.</p>
<pre><code class="lang-perl">my $result = springpe $x
# or in a pipeline:
@list |> map springpe |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-spw">
<h3><a class="doc-anchor" href="#doc-spw">#</a> <code>spw</code></h3>
<p><code>spw</code> — algebraic match builtin. Alias for <code>split_with</code>.</p>
<pre><code class="lang-perl">my $result = spw $x
# or in a pipeline:
@list |> map spw |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sql">
<h3><a class="doc-anchor" href="#doc-sql">#</a> <code>sql</code></h3>
<p><code>sql</code> — data / network builtin. Alias for <code>sqlite</code>.</p>
<pre><code class="lang-perl">my $result = sql $x
# or in a pipeline:
@list |> map sql |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sqr">
<h3><a class="doc-anchor" href="#doc-sqr">#</a> <code>sqr</code></h3>
<p><code>sqr</code> — trig / math (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = sqr $x
# or in a pipeline:
@list |> map sqr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sqrt2">
<h3><a class="doc-anchor" href="#doc-sqrt2">#</a> <code>sqrt2</code></h3>
<p><code>sqrt2</code> — math / physics constants builtin.</p>
<pre><code class="lang-perl">my $result = sqrt2 $x
# or in a pipeline:
@list |> map sqrt2 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sqrt-each">
<h3><a class="doc-anchor" href="#doc-sqrt-each">#</a> <code>sqrt_each</code></h3>
<p><code>sqrt_each</code> — trivial numeric helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = sqrt_each $x
# or in a pipeline:
@list |> map sqrt_each |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-square-each">
<h3><a class="doc-anchor" href="#doc-square-each">#</a> <code>square_each</code></h3>
<p><code>square_each</code> — trivial numeric helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = square_each $x
# or in a pipeline:
@list |> map square_each |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-square-root">
<h3><a class="doc-anchor" href="#doc-square-root">#</a> <code>square_root</code></h3>
<p><code>square_root</code> — math functions builtin.</p>
<pre><code class="lang-perl">my $result = square_root $x
# or in a pipeline:
@list |> map square_root |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-squares-seq">
<h3><a class="doc-anchor" href="#doc-squares-seq">#</a> <code>squares_seq</code></h3>
<p><code>squares_seq</code> — sequences builtin.</p>
<pre><code class="lang-perl">my $result = squares_seq $x
# or in a pipeline:
@list |> map squares_seq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-squish">
<h3><a class="doc-anchor" href="#doc-squish">#</a> <code>squish</code></h3>
<p><code>squish</code> — trivial string ops builtin.</p>
<pre><code class="lang-perl">my $result = squish $x
# or in a pipeline:
@list |> map squish |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-srton">
<h3><a class="doc-anchor" href="#doc-srton">#</a> <code>srton</code></h3>
<p><code>srton</code> — haskell list functions builtin. Alias for <code>sort_on</code>.</p>
<pre><code class="lang-perl">my $result = srton $x
# or in a pipeline:
@list |> map srton |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stack-new">
<h3><a class="doc-anchor" href="#doc-stack-new">#</a> <code>stack_new</code></h3>
<p><code>stack_new</code> — data structure helpers builtin.</p>
<pre><code class="lang-perl">my $result = stack_new $x
# or in a pipeline:
@list |> map stack_new |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-standard-error">
<h3><a class="doc-anchor" href="#doc-standard-error">#</a> <code>standard_error</code></h3>
<p><code>standard_error</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = standard_error $x
# or in a pipeline:
@list |> map standard_error |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-starmap">
<h3><a class="doc-anchor" href="#doc-starmap">#</a> <code>starmap</code></h3>
<p><code>starmap</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = starmap $x
# or in a pipeline:
@list |> map starmap |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-start-of-day">
<h3><a class="doc-anchor" href="#doc-start-of-day">#</a> <code>start_of_day</code></h3>
<p><code>start_of_day</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = start_of_day $x
# or in a pipeline:
@list |> map start_of_day |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-start-of-hour">
<h3><a class="doc-anchor" href="#doc-start-of-hour">#</a> <code>start_of_hour</code></h3>
<p><code>start_of_hour</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = start_of_hour $x
# or in a pipeline:
@list |> map start_of_hour |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-start-of-minute">
<h3><a class="doc-anchor" href="#doc-start-of-minute">#</a> <code>start_of_minute</code></h3>
<p><code>start_of_minute</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = start_of_minute $x
# or in a pipeline:
@list |> map start_of_minute |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-starts-with">
<h3><a class="doc-anchor" href="#doc-starts-with">#</a> <code>starts_with</code></h3>
<p><code>starts_with</code> — trivial string ops builtin.</p>
<pre><code class="lang-perl">my $result = starts_with $x
# or in a pipeline:
@list |> map starts_with |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-starts-with-any">
<h3><a class="doc-anchor" href="#doc-starts-with-any">#</a> <code>starts_with_any</code></h3>
<p><code>starts_with_any</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = starts_with_any $x
# or in a pipeline:
@list |> map starts_with_any |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stats-describe">
<h3><a class="doc-anchor" href="#doc-stats-describe">#</a> <code>stats_describe</code></h3>
<p><code>stats_describe</code> — statistics (extended) builtin. Alias for <code>describe</code>.</p>
<pre><code class="lang-perl">my $result = stats_describe $x
# or in a pipeline:
@list |> map stats_describe |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stderr-stat">
<h3><a class="doc-anchor" href="#doc-stderr-stat">#</a> <code>stderr_stat</code></h3>
<p><code>stderr_stat</code> — math / numeric (uncategorized batch) builtin. Alias for <code>standard_error</code>.</p>
<pre><code class="lang-perl">my $result = stderr_stat $x
# or in a pipeline:
@list |> map stderr_stat |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stefan-boltzmann">
<h3><a class="doc-anchor" href="#doc-stefan-boltzmann">#</a> <code>stefan_boltzmann</code></h3>
<p><code>stefan_boltzmann</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = stefan_boltzmann $x
# or in a pipeline:
@list |> map stefan_boltzmann |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stefan-boltzmann-constant">
<h3><a class="doc-anchor" href="#doc-stefan-boltzmann-constant">#</a> <code>stefan_boltzmann_constant</code></h3>
<p><code>stefan_boltzmann_constant</code> — physics constants builtin.</p>
<pre><code class="lang-perl">my $result = stefan_boltzmann_constant $x
# or in a pipeline:
@list |> map stefan_boltzmann_constant |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stefboltz">
<h3><a class="doc-anchor" href="#doc-stefboltz">#</a> <code>stefboltz</code></h3>
<p><code>stefboltz</code> — physics formulas builtin. Alias for <code>stefan_boltzmann</code>.</p>
<pre><code class="lang-perl">my $result = stefboltz $x
# or in a pipeline:
@list |> map stefboltz |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-step">
<h3><a class="doc-anchor" href="#doc-step">#</a> <code>step</code></h3>
<p><code>step</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = step $x
# or in a pipeline:
@list |> map step |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stirling">
<h3><a class="doc-anchor" href="#doc-stirling">#</a> <code>stirling</code></h3>
<p><code>stirling</code> — math formulas builtin. Alias for <code>stirling_approx</code>.</p>
<pre><code class="lang-perl">my $result = stirling $x
# or in a pipeline:
@list |> map stirling |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stirling2">
<h3><a class="doc-anchor" href="#doc-stirling2">#</a> <code>stirling2</code></h3>
<p><code>stirling2</code> (alias <code>stirling_second</code>) computes the Stirling number of the second kind S(n,k) — the number of ways to partition n elements into k non-empty subsets.</p>
<pre><code class="lang-perl">p stirling2(4, 2) # 7
p stirling2(5, 3) # 25
</code></pre>
</article>
<article class="doc-entry" id="doc-stirling-approx">
<h3><a class="doc-anchor" href="#doc-stirling-approx">#</a> <code>stirling_approx</code></h3>
<p><code>stirling_approx</code> — math formulas builtin.</p>
<pre><code class="lang-perl">my $result = stirling_approx $x
# or in a pipeline:
@list |> map stirling_approx |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-stone-to-kg">
<h3><a class="doc-anchor" href="#doc-stone-to-kg">#</a> <code>stone_to_kg</code></h3>
<p><code>stone_to_kg</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = stone_to_kg $input
</code></pre>
</article>
<article class="doc-entry" id="doc-strdist">
<h3><a class="doc-anchor" href="#doc-strdist">#</a> <code>strdist</code></h3>
<p><code>strdist</code> — string processing (uncategorized batch) builtin. Alias for <code>string_distance</code>.</p>
<pre><code class="lang-perl">my $result = strdist $x
# or in a pipeline:
@list |> map strdist |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-strikethrough">
<h3><a class="doc-anchor" href="#doc-strikethrough">#</a> <code>strikethrough</code></h3>
<p><code>strikethrough</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = strikethrough $x
# or in a pipeline:
@list |> map strikethrough |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-string-count">
<h3><a class="doc-anchor" href="#doc-string-count">#</a> <code>string_count</code></h3>
<p><code>string_count</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = string_count $x
# or in a pipeline:
@list |> map string_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-string-distance">
<h3><a class="doc-anchor" href="#doc-string-distance">#</a> <code>string_distance</code></h3>
<p><code>string_distance</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = string_distance $x
# or in a pipeline:
@list |> map string_distance |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-string-multiply">
<h3><a class="doc-anchor" href="#doc-string-multiply">#</a> <code>string_multiply</code></h3>
<p><code>string_multiply</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = string_multiply $x
# or in a pipeline:
@list |> map string_multiply |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-string-sort">
<h3><a class="doc-anchor" href="#doc-string-sort">#</a> <code>string_sort</code></h3>
<p><code>string_sort</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = string_sort $x
# or in a pipeline:
@list |> map string_sort |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-string-to-chars">
<h3><a class="doc-anchor" href="#doc-string-to-chars">#</a> <code>string_to_chars</code></h3>
<p><code>string_to_chars</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = string_to_chars $input
</code></pre>
</article>
<article class="doc-entry" id="doc-string-unique-chars">
<h3><a class="doc-anchor" href="#doc-string-unique-chars">#</a> <code>string_unique_chars</code></h3>
<p><code>string_unique_chars</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = string_unique_chars $x
# or in a pipeline:
@list |> map string_unique_chars |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-strip-ansi">
<h3><a class="doc-anchor" href="#doc-strip-ansi">#</a> <code>strip_ansi</code></h3>
<p><code>strip_ansi</code> — color / ansi builtin.</p>
<pre><code class="lang-perl">my $result = strip_ansi $x
# or in a pipeline:
@list |> map strip_ansi |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-strip-html">
<h3><a class="doc-anchor" href="#doc-strip-html">#</a> <code>strip_html</code></h3>
<p><code>strip_html</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = strip_html $x
# or in a pipeline:
@list |> map strip_html |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-strip-prefix">
<h3><a class="doc-anchor" href="#doc-strip-prefix">#</a> <code>strip_prefix</code></h3>
<p><code>strip_prefix</code> — path helpers builtin.</p>
<pre><code class="lang-perl">my $result = strip_prefix $x
# or in a pipeline:
@list |> map strip_prefix |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-strip-suffix">
<h3><a class="doc-anchor" href="#doc-strip-suffix">#</a> <code>strip_suffix</code></h3>
<p><code>strip_suffix</code> — path helpers builtin.</p>
<pre><code class="lang-perl">my $result = strip_suffix $x
# or in a pipeline:
@list |> map strip_suffix |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-strmul">
<h3><a class="doc-anchor" href="#doc-strmul">#</a> <code>strmul</code></h3>
<p><code>strmul</code> — string processing (uncategorized batch) builtin. Alias for <code>string_multiply</code>.</p>
<pre><code class="lang-perl">my $result = strmul $x
# or in a pipeline:
@list |> map strmul |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-student-pdf">
<h3><a class="doc-anchor" href="#doc-student-pdf">#</a> <code>student_pdf</code></h3>
<p><code>t_pdf</code> (alias <code>tpdf</code>) evaluates Student's t-distribution PDF at x with nu degrees of freedom.</p>
<pre><code class="lang-perl">p tpdf(0, 10) # peak of t(10)
p tpdf(2.228, 10)
</code></pre>
</article>
<article class="doc-entry" id="doc-sub-script">
<h3><a class="doc-anchor" href="#doc-sub-script">#</a> <code>sub_script</code></h3>
<p><code>sub_script</code> — encoding / phonetics builtin. Alias for <code>subscript</code>.</p>
<pre><code class="lang-perl">my $result = sub_script $x
# or in a pipeline:
@list |> map sub_script |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-subfact">
<h3><a class="doc-anchor" href="#doc-subfact">#</a> <code>subfact</code></h3>
<p><code>subfact</code> — math / numeric (uncategorized batch) builtin. Alias for <code>subfactorial</code>.</p>
<pre><code class="lang-perl">my $result = subfact $x
# or in a pipeline:
@list |> map subfact |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-subfactorial">
<h3><a class="doc-anchor" href="#doc-subfactorial">#</a> <code>subfactorial</code></h3>
<p><code>subfactorial</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = subfactorial $x
# or in a pipeline:
@list |> map subfactorial |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-subscript">
<h3><a class="doc-anchor" href="#doc-subscript">#</a> <code>subscript</code></h3>
<p><code>subscript</code> — encoding / phonetics builtin.</p>
<pre><code class="lang-perl">my $result = subscript $x
# or in a pipeline:
@list |> map subscript |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-subseqs">
<h3><a class="doc-anchor" href="#doc-subseqs">#</a> <code>subseqs</code></h3>
<p><code>subseqs</code> — additional missing stdlib functions builtin. Alias for <code>subsequences</code>.</p>
<pre><code class="lang-perl">my $result = subseqs $x
# or in a pipeline:
@list |> map subseqs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-subsequences">
<h3><a class="doc-anchor" href="#doc-subsequences">#</a> <code>subsequences</code></h3>
<p><code>subsequences</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = subsequences $x
# or in a pipeline:
@list |> map subsequences |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-substring">
<h3><a class="doc-anchor" href="#doc-substring">#</a> <code>substring</code></h3>
<p><code>substring</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = substring $x
# or in a pipeline:
@list |> map substring |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-succ">
<h3><a class="doc-anchor" href="#doc-succ">#</a> <code>succ</code></h3>
<p><code>succ</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = succ $x
# or in a pipeline:
@list |> map succ |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-suffix-sums">
<h3><a class="doc-anchor" href="#doc-suffix-sums">#</a> <code>suffix_sums</code></h3>
<p><code>suffix_sums</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = suffix_sums $x
# or in a pipeline:
@list |> map suffix_sums |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sum-by">
<h3><a class="doc-anchor" href="#doc-sum-by">#</a> <code>sum_by</code></h3>
<p><code>sum_by</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = sum_by $x
# or in a pipeline:
@list |> map sum_by |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sum-divisors">
<h3><a class="doc-anchor" href="#doc-sum-divisors">#</a> <code>sum_divisors</code></h3>
<p><code>sum_divisors</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = sum_divisors $x
# or in a pipeline:
@list |> map sum_divisors |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sum-list">
<h3><a class="doc-anchor" href="#doc-sum-list">#</a> <code>sum_list</code></h3>
<p><code>sum_list</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = sum_list $x
# or in a pipeline:
@list |> map sum_list |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sum-of">
<h3><a class="doc-anchor" href="#doc-sum-of">#</a> <code>sum_of</code></h3>
<p><code>sum_of</code> — more list helpers builtin.</p>
<pre><code class="lang-perl">my $result = sum_of $x
# or in a pipeline:
@list |> map sum_of |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sum-squares">
<h3><a class="doc-anchor" href="#doc-sum-squares">#</a> <code>sum_squares</code></h3>
<p><code>sum_squares</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = sum_squares $x
# or in a pipeline:
@list |> map sum_squares |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sumb">
<h3><a class="doc-anchor" href="#doc-sumb">#</a> <code>sumb</code></h3>
<p><code>sumb</code> — python/ruby stdlib builtin. Alias for <code>sum_by</code>.</p>
<pre><code class="lang-perl">my $result = sumb $x
# or in a pipeline:
@list |> map sumb |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sumsq">
<h3><a class="doc-anchor" href="#doc-sumsq">#</a> <code>sumsq</code></h3>
<p><code>sumsq</code> — extended stdlib builtin. Alias for <code>sum_squares</code>.</p>
<pre><code class="lang-perl">my $result = sumsq $x
# or in a pipeline:
@list |> map sumsq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sun-radius">
<h3><a class="doc-anchor" href="#doc-sun-radius">#</a> <code>sun_radius</code></h3>
<p><code>sun_radius</code> — physics constants builtin.</p>
<pre><code class="lang-perl">my $result = sun_radius $x
# or in a pipeline:
@list |> map sun_radius |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sup">
<h3><a class="doc-anchor" href="#doc-sup">#</a> <code>sup</code></h3>
<p><code>sup</code> — encoding / phonetics builtin. Alias for <code>superscript</code>.</p>
<pre><code class="lang-perl">my $result = sup $x
# or in a pipeline:
@list |> map sup |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-supergolden">
<h3><a class="doc-anchor" href="#doc-supergolden">#</a> <code>supergolden</code></h3>
<p><code>supergolden</code> — math constants builtin. Alias for <code>supergolden_ratio</code>.</p>
<pre><code class="lang-perl">my $result = supergolden $x
# or in a pipeline:
@list |> map supergolden |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-supergolden-ratio">
<h3><a class="doc-anchor" href="#doc-supergolden-ratio">#</a> <code>supergolden_ratio</code></h3>
<p><code>supergolden_ratio</code> — math constants builtin.</p>
<pre><code class="lang-perl">my $result = supergolden_ratio $x
# or in a pipeline:
@list |> map supergolden_ratio |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-superscript">
<h3><a class="doc-anchor" href="#doc-superscript">#</a> <code>superscript</code></h3>
<p><code>superscript</code> — encoding / phonetics builtin.</p>
<pre><code class="lang-perl">my $result = superscript $x
# or in a pipeline:
@list |> map superscript |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sw">
<h3><a class="doc-anchor" href="#doc-sw">#</a> <code>sw</code></h3>
<p><code>sw</code> — trivial string ops builtin. Alias for <code>starts_with</code>.</p>
<pre><code class="lang-perl">my $result = sw $x
# or in a pipeline:
@list |> map sw |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-swap-case">
<h3><a class="doc-anchor" href="#doc-swap-case">#</a> <code>swap_case</code></h3>
<p><code>swap_case</code> — trivial string ops builtin.</p>
<pre><code class="lang-perl">my $result = swap_case $x
# or in a pipeline:
@list |> map swap_case |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-swap-free">
<h3><a class="doc-anchor" href="#doc-swap-free">#</a> <code>swap_free</code></h3>
<p><code>swap_free</code> — free swap space in bytes.</p>
<pre><code class="lang-perl">p format_bytes(swap_free)
my $pct = swap_total > 0 ? int(swap_free / swap_total * 100) : 100
p "$pct% swap free"
</code></pre>
</article>
<article class="doc-entry" id="doc-swap-pairs">
<h3><a class="doc-anchor" href="#doc-swap-pairs">#</a> <code>swap_pairs</code></h3>
<p><code>swap_pairs</code> — collection helpers (trivial) builtin.</p>
<pre><code class="lang-perl">my $result = swap_pairs $x
# or in a pipeline:
@list |> map swap_pairs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-swap-total">
<h3><a class="doc-anchor" href="#doc-swap-total">#</a> <code>swap_total</code></h3>
<p><code>swap_total</code> — total swap space in bytes. Linux: <code>/proc/meminfo SwapTotal</code>. macOS: <code>vm.swapusage</code> sysctl. Returns 0 if swap is disabled, <code>undef</code> on unsupported platforms.</p>
<pre><code class="lang-perl">p swap_total # 8589934592
p format_bytes(swap_total) # 8.0 GiB
</code></pre>
</article>
<article class="doc-entry" id="doc-swap-used">
<h3><a class="doc-anchor" href="#doc-swap-used">#</a> <code>swap_used</code></h3>
<p><code>swap_used</code> — used swap space in bytes (total - free).</p>
<pre><code class="lang-perl">p format_bytes(swap_used)
p "swap pressure" if swap_used > swap_total * 0.8
</code></pre>
</article>
<article class="doc-entry" id="doc-sym-links">
<h3><a class="doc-anchor" href="#doc-sym-links">#</a> <code>sym_links</code></h3>
<p><code>sym_links</code> — filesystem extensions builtin.</p>
<pre><code class="lang-perl">my $result = sym_links $x
# or in a pipeline:
@list |> map sym_links |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-symmetric-diff">
<h3><a class="doc-anchor" href="#doc-symmetric-diff">#</a> <code>symmetric_diff</code></h3>
<p><code>symmetric_diff</code> — collection (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = symmetric_diff $x
# or in a pipeline:
@list |> map symmetric_diff |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-sys-uptime">
<h3><a class="doc-anchor" href="#doc-sys-uptime">#</a> <code>sys_uptime</code></h3>
<p><code>sys_uptime</code> — system uptime in seconds (float). On Linux reads <code>/proc/uptime</code>. On macOS uses <code>kern.boottime</code> sysctl. This is the wall-clock uptime of the machine, not the stryke process (see <code>uptime_secs</code> for process uptime).</p>
<pre><code class="lang-perl">p sys_uptime # 147951.5
my $days = int(sys_uptime / 86400)
p "up $days days"
</code></pre>
</article>
<article class="doc-entry" id="doc-t-test-one-sample">
<h3><a class="doc-anchor" href="#doc-t-test-one-sample">#</a> <code>t_test_one_sample</code></h3>
<p><code>t_test_one_sample($mu, @sample)</code> (alias <code>ttest1</code>) — performs a one-sample t-test comparing a sample mean against a hypothesized population mean mu. Returns [t_statistic, degrees_of_freedom]. Use t-distribution tables for p-value lookup.</p>
<pre><code class="lang-perl">my @sample = (5.1, 4.9, 5.2, 5.0, 4.8)
my $result = ttest1(5.0, @sample)
p "t=$result->[0] df=$result->[1]"
</code></pre>
</article>
<article class="doc-entry" id="doc-t-test-two-sample">
<h3><a class="doc-anchor" href="#doc-t-test-two-sample">#</a> <code>t_test_two_sample</code></h3>
<p><code>t_test_two_sample(\@a, \@b)</code> (alias <code>ttest2</code>) — performs an independent two-sample t-test comparing means of two samples. Assumes equal variances. Returns [t_statistic, degrees_of_freedom].</p>
<pre><code class="lang-perl">my @a = (5.1, 5.3, 4.9)
my @b = (4.2, 4.5, 4.1)
my $r = ttest2(\@a, \@b)
p "t=$r->[0] df=$r->[1]"
</code></pre>
</article>
<article class="doc-entry" id="doc-tabulate">
<h3><a class="doc-anchor" href="#doc-tabulate">#</a> <code>tabulate</code></h3>
<p><code>tabulate</code> — frequency table of values. Returns hash of value => count. Like R's table().</p>
<pre><code class="lang-perl">my %t = %{tabulate([qw(a b a c b a)])}
p $t{a} # 3
</code></pre>
</article>
<article class="doc-entry" id="doc-tail-lines">
<h3><a class="doc-anchor" href="#doc-tail-lines">#</a> <code>tail_lines</code></h3>
<p><code>tail_lines</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = tail_lines $x
# or in a pipeline:
@list |> map tail_lines |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tail-n">
<h3><a class="doc-anchor" href="#doc-tail-n">#</a> <code>tail_n</code></h3>
<p><code>tail_n</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = tail_n $x
# or in a pipeline:
@list |> map tail_n |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tail-str">
<h3><a class="doc-anchor" href="#doc-tail-str">#</a> <code>tail_str</code></h3>
<p><code>tail_str</code> — string (batch 2) builtin. Alias for <code>right_str</code>.</p>
<pre><code class="lang-perl">my $result = tail_str $x
# or in a pipeline:
@list |> map tail_str |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tails">
<h3><a class="doc-anchor" href="#doc-tails">#</a> <code>tails</code></h3>
<p><code>tails</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = tails $x
# or in a pipeline:
@list |> map tails |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-take-every">
<h3><a class="doc-anchor" href="#doc-take-every">#</a> <code>take_every</code></h3>
<p><code>take_every</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = take_every $x
# or in a pipeline:
@list |> map take_every |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-take-last">
<h3><a class="doc-anchor" href="#doc-take-last">#</a> <code>take_last</code></h3>
<p><code>take_last</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = take_last $x
# or in a pipeline:
@list |> map take_last |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-take-n">
<h3><a class="doc-anchor" href="#doc-take-n">#</a> <code>take_n</code></h3>
<p><code>take_n</code> — collection helpers (trivial) builtin.</p>
<pre><code class="lang-perl">my $result = take_n $x
# or in a pipeline:
@list |> map take_n |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-talb">
<h3><a class="doc-anchor" href="#doc-talb">#</a> <code>talb</code></h3>
<p><code>talb</code> — ruby enumerable extras builtin. Alias for <code>tally_by</code>.</p>
<pre><code class="lang-perl">my $result = talb $x
# or in a pipeline:
@list |> map talb |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tally-by">
<h3><a class="doc-anchor" href="#doc-tally-by">#</a> <code>tally_by</code></h3>
<p><code>tally_by</code> — ruby enumerable extras builtin.</p>
<pre><code class="lang-perl">my $result = tally_by $x
# or in a pipeline:
@list |> map tally_by |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tan">
<h3><a class="doc-anchor" href="#doc-tan">#</a> <code>tan</code></h3>
<p><code>tan</code> — trig / math (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = tan $x
# or in a pipeline:
@list |> map tan |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tanh">
<h3><a class="doc-anchor" href="#doc-tanh">#</a> <code>tanh</code></h3>
<p><code>tanh</code> — trig / math (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = tanh $x
# or in a pipeline:
@list |> map tanh |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tap-debug">
<h3><a class="doc-anchor" href="#doc-tap-debug">#</a> <code>tap_debug</code></h3>
<p><code>tap_debug</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = tap_debug $x
# or in a pipeline:
@list |> map tap_debug |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tap-val">
<h3><a class="doc-anchor" href="#doc-tap-val">#</a> <code>tap_val</code></h3>
<p><code>tap_val</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = tap_val $x
# or in a pipeline:
@list |> map tap_val |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tapply">
<h3><a class="doc-anchor" href="#doc-tapply">#</a> <code>tapply</code></h3>
<p><code>tapply</code> — apply a function by group. Takes data, group labels, and function. Returns hash. Like R's tapply().</p>
<pre><code class="lang-perl">my %means = %{tapply([1,2,3,4], ["a","a","b","b"], fn { avg(@{$_[0]}) })}
p $means{a} # 1.5
p $means{b} # 3.5
</code></pre>
</article>
<article class="doc-entry" id="doc-tau">
<h3><a class="doc-anchor" href="#doc-tau">#</a> <code>tau</code></h3>
<p><code>tau</code> — constants builtin.</p>
<pre><code class="lang-perl">my $result = tau $x
# or in a pipeline:
@list |> map tau |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tax">
<h3><a class="doc-anchor" href="#doc-tax">#</a> <code>tax</code></h3>
<p><code>tax</code> — finance builtin.</p>
<pre><code class="lang-perl">my $result = tax $x
# or in a pipeline:
@list |> map tax |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tax-amount">
<h3><a class="doc-anchor" href="#doc-tax-amount">#</a> <code>tax_amount</code></h3>
<p><code>tax_amount</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = tax_amount $x
# or in a pipeline:
@list |> map tax_amount |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tcrossprod">
<h3><a class="doc-anchor" href="#doc-tcrossprod">#</a> <code>tcrossprod</code></h3>
<p><code>tcrossprod</code> — M * t(M) (R's tcrossprod).</p>
<pre><code class="lang-perl">my $aat = tcrossprod([[1,2],[3,4]]) # [[5,11],[11,25]]
</code></pre>
</article>
<article class="doc-entry" id="doc-td">
<h3><a class="doc-anchor" href="#doc-td">#</a> <code>td</code></h3>
<p><code>td</code> — serialization (stryke-only encoders) builtin. Alias for <code>toml_decode</code>.</p>
<pre><code class="lang-perl">my $result = td $x
# or in a pipeline:
@list |> map td |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tdilate">
<h3><a class="doc-anchor" href="#doc-tdilate">#</a> <code>tdilate</code></h3>
<p><code>time_dilation($proper_time, $velocity)</code> (alias <code>tdilate</code>) — dilated time Δt = Δt₀ × γ. Time appears to slow for moving objects.</p>
<pre><code class="lang-perl">p tdilate(1, 0.99 * 3e8) # ~7.09 s (1 second at 99% c)
</code></pre>
</article>
<article class="doc-entry" id="doc-te">
<h3><a class="doc-anchor" href="#doc-te">#</a> <code>te</code></h3>
<p><code>te</code> — serialization (stryke-only encoders) builtin. Alias for <code>toml_encode</code>.</p>
<pre><code class="lang-perl">my $result = te $x
# or in a pipeline:
@list |> map te |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tee-iter">
<h3><a class="doc-anchor" href="#doc-tee-iter">#</a> <code>tee_iter</code></h3>
<p><code>tee_iter</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = tee_iter $x
# or in a pipeline:
@list |> map tee_iter |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-teei">
<h3><a class="doc-anchor" href="#doc-teei">#</a> <code>teei</code></h3>
<p><code>teei</code> — python/ruby stdlib builtin. Alias for <code>tee_iter</code>.</p>
<pre><code class="lang-perl">my $result = teei $x
# or in a pipeline:
@list |> map teei |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-temp-dir">
<h3><a class="doc-anchor" href="#doc-temp-dir">#</a> <code>temp_dir</code></h3>
<p><code>temp_dir</code> — system introspection builtin.</p>
<pre><code class="lang-perl">my $result = temp_dir $x
# or in a pipeline:
@list |> map temp_dir |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tempplanck">
<h3><a class="doc-anchor" href="#doc-tempplanck">#</a> <code>tempplanck</code></h3>
<p><code>tempplanck</code> — physics constants builtin. Alias for <code>planck_temperature</code>.</p>
<pre><code class="lang-perl">my $result = tempplanck $x
# or in a pipeline:
@list |> map tempplanck |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-text-after">
<h3><a class="doc-anchor" href="#doc-text-after">#</a> <code>text_after</code></h3>
<p><code>text_after</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = text_after $x
# or in a pipeline:
@list |> map text_after |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-text-after-last">
<h3><a class="doc-anchor" href="#doc-text-after-last">#</a> <code>text_after_last</code></h3>
<p><code>text_after_last</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = text_after_last $x
# or in a pipeline:
@list |> map text_after_last |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-text-before">
<h3><a class="doc-anchor" href="#doc-text-before">#</a> <code>text_before</code></h3>
<p><code>text_before</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = text_before $x
# or in a pipeline:
@list |> map text_before |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-text-before-last">
<h3><a class="doc-anchor" href="#doc-text-before-last">#</a> <code>text_before_last</code></h3>
<p><code>text_before_last</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = text_before_last $x
# or in a pipeline:
@list |> map text_before_last |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-text-between">
<h3><a class="doc-anchor" href="#doc-text-between">#</a> <code>text_between</code></h3>
<p><code>text_between</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = text_between $x
# or in a pipeline:
@list |> map text_between |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tfld">
<h3><a class="doc-anchor" href="#doc-tfld">#</a> <code>tfld</code></h3>
<p><code>tfld</code> — rust iterator methods builtin. Alias for <code>try_fold</code>.</p>
<pre><code class="lang-perl">my $result = tfld $x
# or in a pipeline:
@list |> map tfld |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-then-fn">
<h3><a class="doc-anchor" href="#doc-then-fn">#</a> <code>then_fn</code></h3>
<p><code>then_fn</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = then_fn $x
# or in a pipeline:
@list |> map then_fn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-thfn">
<h3><a class="doc-anchor" href="#doc-thfn">#</a> <code>thfn</code></h3>
<p><code>thfn</code> — python/ruby stdlib builtin. Alias for <code>then_fn</code>.</p>
<pre><code class="lang-perl">my $result = thfn $x
# or in a pipeline:
@list |> map thfn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-thin-lens">
<h3><a class="doc-anchor" href="#doc-thin-lens">#</a> <code>thin_lens</code></h3>
<p><code>thin_lens($object_dist, $focal_length)</code> (alias <code>thinlens</code>) — image distance using 1/f = 1/do + 1/di.</p>
<pre><code class="lang-perl">p thinlens(30, 20) # 60 cm (real image)
p thinlens(10, 20) # -20 cm (virtual image)
</code></pre>
</article>
<article class="doc-entry" id="doc-third-elem">
<h3><a class="doc-anchor" href="#doc-third-elem">#</a> <code>third_elem</code></h3>
<p><code>third_elem</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = third_elem $x
# or in a pipeline:
@list |> map third_elem |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tied">
<h3><a class="doc-anchor" href="#doc-tied">#</a> <code>tied</code></h3>
<p><code>tied</code> — type / reflection builtin.</p>
<pre><code class="lang-perl">my $result = tied $x
# or in a pipeline:
@list |> map tied |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-times-fn">
<h3><a class="doc-anchor" href="#doc-times-fn">#</a> <code>times_fn</code></h3>
<p><code>times_fn</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = times_fn $x
# or in a pipeline:
@list |> map times_fn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-timf">
<h3><a class="doc-anchor" href="#doc-timf">#</a> <code>timf</code></h3>
<p><code>timf</code> — python/ruby stdlib builtin. Alias for <code>times_fn</code>.</p>
<pre><code class="lang-perl">my $result = timf $x
# or in a pipeline:
@list |> map timf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tip">
<h3><a class="doc-anchor" href="#doc-tip">#</a> <code>tip</code></h3>
<p><code>tip</code> — finance builtin.</p>
<pre><code class="lang-perl">my $result = tip $x
# or in a pipeline:
@list |> map tip |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tip-amount">
<h3><a class="doc-anchor" href="#doc-tip-amount">#</a> <code>tip_amount</code></h3>
<p><code>tip_amount</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = tip_amount $x
# or in a pipeline:
@list |> map tip_amount |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-title">
<h3><a class="doc-anchor" href="#doc-title">#</a> <code>title</code></h3>
<p><code>title</code> — trivial string ops builtin. Alias for <code>title_case</code>.</p>
<pre><code class="lang-perl">my $result = title $x
# or in a pipeline:
@list |> map title |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-title-case">
<h3><a class="doc-anchor" href="#doc-title-case">#</a> <code>title_case</code></h3>
<p><code>title_case</code> — trivial string ops builtin.</p>
<pre><code class="lang-perl">my $result = title_case $x
# or in a pipeline:
@list |> map title_case |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tkeys">
<h3><a class="doc-anchor" href="#doc-tkeys">#</a> <code>tkeys</code></h3>
<p><code>tkeys</code> — python/ruby stdlib builtin. Alias for <code>transform_keys</code>.</p>
<pre><code class="lang-perl">my $result = tkeys $x
# or in a pipeline:
@list |> map tkeys |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-to-array">
<h3><a class="doc-anchor" href="#doc-to-array">#</a> <code>to_array</code></h3>
<p><code>to_array</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = to_array $input
</code></pre>
</article>
<article class="doc-entry" id="doc-to-ascii">
<h3><a class="doc-anchor" href="#doc-to-ascii">#</a> <code>to_ascii</code></h3>
<p><code>to_ascii</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = to_ascii $input
</code></pre>
</article>
<article class="doc-entry" id="doc-to-base">
<h3><a class="doc-anchor" href="#doc-to-base">#</a> <code>to_base</code></h3>
<p><code>to_base</code> — base conversion builtin.</p>
<pre><code class="lang-perl">my $result = to_base $input
</code></pre>
</article>
<article class="doc-entry" id="doc-to-bin">
<h3><a class="doc-anchor" href="#doc-to-bin">#</a> <code>to_bin</code></h3>
<p><code>to_bin</code> — base conversion builtin.</p>
<pre><code class="lang-perl">my $result = to_bin $input
</code></pre>
</article>
<article class="doc-entry" id="doc-to-bool">
<h3><a class="doc-anchor" href="#doc-to-bool">#</a> <code>to_bool</code></h3>
<p><code>to_bool</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = to_bool $input
</code></pre>
</article>
<article class="doc-entry" id="doc-to-csv-line">
<h3><a class="doc-anchor" href="#doc-to-csv-line">#</a> <code>to_csv_line</code></h3>
<p><code>to_csv_line</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = to_csv_line $input
</code></pre>
</article>
<article class="doc-entry" id="doc-to-emoji-num">
<h3><a class="doc-anchor" href="#doc-to-emoji-num">#</a> <code>to_emoji_num</code></h3>
<p><code>to_emoji_num</code> — encoding / phonetics builtin.</p>
<pre><code class="lang-perl">my $result = to_emoji_num $input
</code></pre>
</article>
<article class="doc-entry" id="doc-to-float">
<h3><a class="doc-anchor" href="#doc-to-float">#</a> <code>to_float</code></h3>
<p><code>to_float</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = to_float $input
</code></pre>
</article>
<article class="doc-entry" id="doc-to-float-each">
<h3><a class="doc-anchor" href="#doc-to-float-each">#</a> <code>to_float_each</code></h3>
<p><code>to_float_each</code> — trivial numeric helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = to_float_each $input
</code></pre>
</article>
<article class="doc-entry" id="doc-to-hash">
<h3><a class="doc-anchor" href="#doc-to-hash">#</a> <code>to_hash</code></h3>
<p><code>to_hash LIST</code> — collect a flat list of key-value pairs into a Perl hash.</p>
<p>The list is consumed two elements at a time: odd-positioned elements become keys and even-positioned elements become values. If there is an odd number of elements, the last key maps to <code>undef</code>. This is a terminal operation that materializes the full stream. Useful for converting pipeline output into a lookup table.</p>
<pre><code class="lang-perl">my %h = qw(a 1 b 2) |> to_hash
@pairs |> to_hash
my %freq = @words |> map { $_, 1 } |> to_hash
</code></pre>
</article>
<article class="doc-entry" id="doc-to-hex">
<h3><a class="doc-anchor" href="#doc-to-hex">#</a> <code>to_hex</code></h3>
<p><code>to_hex</code> — base conversion builtin.</p>
<pre><code class="lang-perl">my $result = to_hex $input
</code></pre>
</article>
<article class="doc-entry" id="doc-to-int">
<h3><a class="doc-anchor" href="#doc-to-int">#</a> <code>to_int</code></h3>
<p><code>to_int</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = to_int $input
</code></pre>
</article>
<article class="doc-entry" id="doc-to-int-each">
<h3><a class="doc-anchor" href="#doc-to-int-each">#</a> <code>to_int_each</code></h3>
<p><code>to_int_each</code> — trivial numeric helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = to_int_each $input
</code></pre>
</article>
<article class="doc-entry" id="doc-to-oct">
<h3><a class="doc-anchor" href="#doc-to-oct">#</a> <code>to_oct</code></h3>
<p><code>to_oct</code> — base conversion builtin.</p>
<pre><code class="lang-perl">my $result = to_oct $input
</code></pre>
</article>
<article class="doc-entry" id="doc-to-pairs">
<h3><a class="doc-anchor" href="#doc-to-pairs">#</a> <code>to_pairs</code></h3>
<p><code>to_pairs</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = to_pairs $input
</code></pre>
</article>
<article class="doc-entry" id="doc-to-reversed">
<h3><a class="doc-anchor" href="#doc-to-reversed">#</a> <code>to_reversed</code></h3>
<p><code>to_reversed</code> — javascript array/object methods builtin.</p>
<pre><code class="lang-perl">my $result = to_reversed $input
</code></pre>
</article>
<article class="doc-entry" id="doc-to-set">
<h3><a class="doc-anchor" href="#doc-to-set">#</a> <code>to_set</code></h3>
<p><code>to_set LIST</code> — collect a list or iterator into a <code>set</code> object with O(1) membership testing.</p>
<p>The resulting set contains only unique elements (duplicates are discarded). This is a terminal operation that materializes the full stream. The returned set supports <code>->contains($val)</code>, <code>->union($other)</code>, <code>->intersection($other)</code>, and <code>->difference($other)</code>. Use this when you need fast repeated lookups against a collection of values.</p>
<pre><code class="lang-perl">my $s = 1..5 |> to_set
@words |> to_set # deduplicated set
my $allowed = to_set @whitelist
p $allowed->contains("foo")
</code></pre>
</article>
<article class="doc-entry" id="doc-to-sorted">
<h3><a class="doc-anchor" href="#doc-to-sorted">#</a> <code>to_sorted</code></h3>
<p><code>to_sorted</code> — javascript array/object methods builtin.</p>
<pre><code class="lang-perl">my $result = to_sorted $input
</code></pre>
</article>
<article class="doc-entry" id="doc-to-spliced">
<h3><a class="doc-anchor" href="#doc-to-spliced">#</a> <code>to_spliced</code></h3>
<p><code>to_spliced</code> — javascript array/object methods builtin.</p>
<pre><code class="lang-perl">my $result = to_spliced $input
</code></pre>
</article>
<article class="doc-entry" id="doc-to-string">
<h3><a class="doc-anchor" href="#doc-to-string">#</a> <code>to_string</code></h3>
<p><code>to_string</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = to_string $input
</code></pre>
</article>
<article class="doc-entry" id="doc-to-string-val">
<h3><a class="doc-anchor" href="#doc-to-string-val">#</a> <code>to_string_val</code></h3>
<p><code>to_string_val</code> — misc / utility builtin.</p>
<pre><code class="lang-perl">my $result = to_string_val $input
</code></pre>
</article>
<article class="doc-entry" id="doc-toasc">
<h3><a class="doc-anchor" href="#doc-toasc">#</a> <code>toasc</code></h3>
<p><code>toasc</code> — extended stdlib builtin. Alias for <code>to_ascii</code>.</p>
<pre><code class="lang-perl">my $result = toasc $x
# or in a pipeline:
@list |> map toasc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-today">
<h3><a class="doc-anchor" href="#doc-today">#</a> <code>today</code></h3>
<p><code>today</code> — date (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = today $x
# or in a pipeline:
@list |> map today |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-token">
<h3><a class="doc-anchor" href="#doc-token">#</a> <code>token</code></h3>
<p><code>token</code> — id helpers builtin.</p>
<pre><code class="lang-perl">my $result = token $x
# or in a pipeline:
@list |> map token |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tomorrow">
<h3><a class="doc-anchor" href="#doc-tomorrow">#</a> <code>tomorrow</code></h3>
<p><code>tomorrow</code> — date (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = tomorrow $x
# or in a pipeline:
@list |> map tomorrow |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-top">
<h3><a class="doc-anchor" href="#doc-top">#</a> <code>top</code></h3>
<p><code>top</code> — pipeline / string helpers builtin.</p>
<pre><code class="lang-perl">my $result = top $x
# or in a pipeline:
@list |> map top |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-topological-sort">
<h3><a class="doc-anchor" href="#doc-topological-sort">#</a> <code>topological_sort</code></h3>
<p><code>topological_sort</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = topological_sort $x
# or in a pipeline:
@list |> map topological_sort |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-toposort">
<h3><a class="doc-anchor" href="#doc-toposort">#</a> <code>toposort</code></h3>
<p><code>toposort</code> — extended stdlib builtin. Alias for <code>topological_sort</code>.</p>
<pre><code class="lang-perl">my $result = toposort $x
# or in a pipeline:
@list |> map toposort |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-torque">
<h3><a class="doc-anchor" href="#doc-torque">#</a> <code>torque</code></h3>
<p><code>torque($force, $lever_arm, $angle)</code> — compute torque τ = r×F×sin(θ) (N⋅m). Angle in degrees, default 90.</p>
<pre><code class="lang-perl">p torque(50, 0.5) # 25 N⋅m (perpendicular force)
p torque(50, 0.5, 30) # 12.5 N⋅m
</code></pre>
</article>
<article class="doc-entry" id="doc-torus-surface">
<h3><a class="doc-anchor" href="#doc-torus-surface">#</a> <code>torus_surface</code></h3>
<p><code>torus_surface($major_r, $minor_r)</code> — computes the surface area of a torus. Returns <code>4π²Rr</code>.</p>
<pre><code class="lang-perl">p torus_surface(10, 2) # ~789.6
</code></pre>
</article>
<article class="doc-entry" id="doc-torus-volume">
<h3><a class="doc-anchor" href="#doc-torus-volume">#</a> <code>torus_volume</code></h3>
<p><code>torus_volume($major_r, $minor_r)</code> — computes the volume of a torus with major radius R (center to tube center) and minor radius r (tube radius). Returns <code>2π²Rr²</code>.</p>
<pre><code class="lang-perl">p torus_volume(10, 2) # ~789.6
</code></pre>
</article>
<article class="doc-entry" id="doc-torussurf">
<h3><a class="doc-anchor" href="#doc-torussurf">#</a> <code>torussurf</code></h3>
<p><code>torussurf</code> — geometry (extended) builtin. Alias for <code>torus_surface</code>.</p>
<pre><code class="lang-perl">my $result = torussurf $x
# or in a pipeline:
@list |> map torussurf |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-torusvol">
<h3><a class="doc-anchor" href="#doc-torusvol">#</a> <code>torusvol</code></h3>
<p><code>torusvol</code> — geometry (extended) builtin. Alias for <code>torus_volume</code>.</p>
<pre><code class="lang-perl">my $result = torusvol $x
# or in a pipeline:
@list |> map torusvol |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-totient-sum">
<h3><a class="doc-anchor" href="#doc-totient-sum">#</a> <code>totient_sum</code></h3>
<p><code>totient_sum</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = totient_sum $x
# or in a pipeline:
@list |> map totient_sum |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-totsum">
<h3><a class="doc-anchor" href="#doc-totsum">#</a> <code>totsum</code></h3>
<p><code>totsum</code> — math / numeric (uncategorized batch) builtin. Alias for <code>totient_sum</code>.</p>
<pre><code class="lang-perl">my $result = totsum $x
# or in a pipeline:
@list |> map totsum |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-touch">
<h3><a class="doc-anchor" href="#doc-touch">#</a> <code>touch</code></h3>
<p><code>touch</code> — filesystem extensions builtin.</p>
<pre><code class="lang-perl">my $result = touch $x
# or in a pipeline:
@list |> map touch |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tower-of-hanoi">
<h3><a class="doc-anchor" href="#doc-tower-of-hanoi">#</a> <code>tower_of_hanoi</code></h3>
<p><code>tower_of_hanoi</code> — algorithms / puzzles builtin.</p>
<pre><code class="lang-perl">my $result = tower_of_hanoi $x
# or in a pipeline:
@list |> map tower_of_hanoi |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tplanck">
<h3><a class="doc-anchor" href="#doc-tplanck">#</a> <code>tplanck</code></h3>
<p><code>tplanck</code> — physics constants builtin. Alias for <code>planck_time</code>.</p>
<pre><code class="lang-perl">my $result = tplanck $x
# or in a pipeline:
@list |> map tplanck |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-trailing-zeros">
<h3><a class="doc-anchor" href="#doc-trailing-zeros">#</a> <code>trailing_zeros</code></h3>
<p><code>trailing_zeros</code> — base conversion builtin.</p>
<pre><code class="lang-perl">my $result = trailing_zeros $x
# or in a pipeline:
@list |> map trailing_zeros |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-transform-keys">
<h3><a class="doc-anchor" href="#doc-transform-keys">#</a> <code>transform_keys</code></h3>
<p><code>transform_keys</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = transform_keys $x
# or in a pipeline:
@list |> map transform_keys |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-transform-values">
<h3><a class="doc-anchor" href="#doc-transform-values">#</a> <code>transform_values</code></h3>
<p><code>transform_values</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = transform_values $x
# or in a pipeline:
@list |> map transform_values |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-translate-point">
<h3><a class="doc-anchor" href="#doc-translate-point">#</a> <code>translate_point</code></h3>
<p><code>translate_point($x, $y, $dx, $dy)</code> — translates a 2D point by offset (dx, dy). Returns [$x+$dx, $y+$dy]. Basic vector addition.</p>
<pre><code class="lang-perl">my $p = translate_point(1, 2, 3, 4)
p @$p # (4, 6)
</code></pre>
</article>
<article class="doc-entry" id="doc-transpose">
<h3><a class="doc-anchor" href="#doc-transpose">#</a> <code>transpose</code></h3>
<p><code>transpose</code> — collection more builtin.</p>
<pre><code class="lang-perl">my $result = transpose $x
# or in a pipeline:
@list |> map transpose |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-transpt">
<h3><a class="doc-anchor" href="#doc-transpt">#</a> <code>transpt</code></h3>
<p><code>transpt</code> — geometry (extended) builtin. Alias for <code>translate_point</code>.</p>
<pre><code class="lang-perl">my $result = transpt $x
# or in a pipeline:
@list |> map transpt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-trapezoid">
<h3><a class="doc-anchor" href="#doc-trapezoid">#</a> <code>trapezoid</code></h3>
<p><code>trapz</code> (alias <code>trapezoid</code>) integrates evenly-spaced samples using the trapezoidal rule. Optional dx (default 1).</p>
<pre><code class="lang-perl">my @y = map { $_ ** 2 } 0..100
p trapz(\@y, 0.01) # ≈ 0.3333
</code></pre>
</article>
<article class="doc-entry" id="doc-trev">
<h3><a class="doc-anchor" href="#doc-trev">#</a> <code>trev</code></h3>
<p><code>trev</code> — javascript array/object methods builtin. Alias for <code>to_reversed</code>.</p>
<pre><code class="lang-perl">my $result = trev $x
# or in a pipeline:
@list |> map trev |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-triangle-hypotenuse">
<h3><a class="doc-anchor" href="#doc-triangle-hypotenuse">#</a> <code>triangle_hypotenuse</code></h3>
<p><code>triangle_hypotenuse</code> — geometry / physics builtin.</p>
<pre><code class="lang-perl">my $result = triangle_hypotenuse $x
# or in a pipeline:
@list |> map triangle_hypotenuse |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-triangular-number">
<h3><a class="doc-anchor" href="#doc-triangular-number">#</a> <code>triangular_number</code></h3>
<p><code>triangular_number</code> — number theory / primes builtin.</p>
<pre><code class="lang-perl">my $result = triangular_number $x
# or in a pipeline:
@list |> map triangular_number |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-triangular-seq">
<h3><a class="doc-anchor" href="#doc-triangular-seq">#</a> <code>triangular_seq</code></h3>
<p><code>triangular_seq</code> — sequences builtin.</p>
<pre><code class="lang-perl">my $result = triangular_seq $x
# or in a pipeline:
@list |> map triangular_seq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-trib">
<h3><a class="doc-anchor" href="#doc-trib">#</a> <code>trib</code></h3>
<p><code>trib</code> — math / numeric (uncategorized batch) builtin. Alias for <code>tribonacci</code>.</p>
<pre><code class="lang-perl">my $result = trib $x
# or in a pipeline:
@list |> map trib |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tribonacci">
<h3><a class="doc-anchor" href="#doc-tribonacci">#</a> <code>tribonacci</code></h3>
<p><code>tribonacci</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = tribonacci $x
# or in a pipeline:
@list |> map tribonacci |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-trigram">
<h3><a class="doc-anchor" href="#doc-trigram">#</a> <code>trigram</code></h3>
<p><code>trigram</code> — string processing (uncategorized batch) builtin. Alias for <code>trigrams</code>.</p>
<pre><code class="lang-perl">my $result = trigram $x
# or in a pipeline:
@list |> map trigram |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-trigrams">
<h3><a class="doc-anchor" href="#doc-trigrams">#</a> <code>trigrams</code></h3>
<p><code>trigrams</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = trigrams $x
# or in a pipeline:
@list |> map trigrams |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-trim-each">
<h3><a class="doc-anchor" href="#doc-trim-each">#</a> <code>trim_each</code></h3>
<p><code>trim_each</code> — trivial numeric helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = trim_each $x
# or in a pipeline:
@list |> map trim_each |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-trim-left">
<h3><a class="doc-anchor" href="#doc-trim-left">#</a> <code>trim_left</code></h3>
<p><code>trim_left</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = trim_left $x
# or in a pipeline:
@list |> map trim_left |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-trim-right">
<h3><a class="doc-anchor" href="#doc-trim-right">#</a> <code>trim_right</code></h3>
<p><code>trim_right</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = trim_right $x
# or in a pipeline:
@list |> map trim_right |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-trimmed-mean">
<h3><a class="doc-anchor" href="#doc-trimmed-mean">#</a> <code>trimmed_mean</code></h3>
<p><code>trimmed_mean</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = trimmed_mean $x
# or in a pipeline:
@list |> map trimmed_mean |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-trinum">
<h3><a class="doc-anchor" href="#doc-trinum">#</a> <code>trinum</code></h3>
<p><code>trinum</code> — number theory / primes builtin. Alias for <code>triangular_number</code>.</p>
<pre><code class="lang-perl">my $result = trinum $x
# or in a pipeline:
@list |> map trinum |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-triple">
<h3><a class="doc-anchor" href="#doc-triple">#</a> <code>triple</code></h3>
<p><code>triple</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = triple $x
# or in a pipeline:
@list |> map triple |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-trunc">
<h3><a class="doc-anchor" href="#doc-trunc">#</a> <code>trunc</code></h3>
<p><code>trunc</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = trunc $x
# or in a pipeline:
@list |> map trunc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-truncate-at">
<h3><a class="doc-anchor" href="#doc-truncate-at">#</a> <code>truncate_at</code></h3>
<p><code>truncate_at</code> — trivial string ops builtin.</p>
<pre><code class="lang-perl">my $result = truncate_at $x
# or in a pipeline:
@list |> map truncate_at |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-truncn">
<h3><a class="doc-anchor" href="#doc-truncn">#</a> <code>truncn</code></h3>
<p><code>truncn</code> — trivial numeric / predicate builtins builtin. Alias for <code>trunc</code>.</p>
<pre><code class="lang-perl">my $result = truncn $x
# or in a pipeline:
@list |> map truncn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-truth-table">
<h3><a class="doc-anchor" href="#doc-truth-table">#</a> <code>truth_table</code></h3>
<p><code>truth_table</code> — algorithms / puzzles builtin.</p>
<pre><code class="lang-perl">my $result = truth_table $x
# or in a pipeline:
@list |> map truth_table |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-truthy-count">
<h3><a class="doc-anchor" href="#doc-truthy-count">#</a> <code>truthy_count</code></h3>
<p><code>truthy_count</code> — counters (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = truthy_count $x
# or in a pipeline:
@list |> map truthy_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-try-fn">
<h3><a class="doc-anchor" href="#doc-try-fn">#</a> <code>try_fn</code></h3>
<p><code>try_fn</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = try_fn $x
# or in a pipeline:
@list |> map try_fn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-try-fold">
<h3><a class="doc-anchor" href="#doc-try-fold">#</a> <code>try_fold</code></h3>
<p><code>try_fold</code> — rust iterator methods builtin.</p>
<pre><code class="lang-perl">my $result = try_fold $x
# or in a pipeline:
@list |> map try_fold |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tspl">
<h3><a class="doc-anchor" href="#doc-tspl">#</a> <code>tspl</code></h3>
<p><code>tspl</code> — javascript array/object methods builtin. Alias for <code>to_spliced</code>.</p>
<pre><code class="lang-perl">my $result = tspl $x
# or in a pipeline:
@list |> map tspl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tsrt">
<h3><a class="doc-anchor" href="#doc-tsrt">#</a> <code>tsrt</code></h3>
<p><code>tsrt</code> — javascript array/object methods builtin. Alias for <code>to_sorted</code>.</p>
<pre><code class="lang-perl">my $result = tsrt $x
# or in a pipeline:
@list |> map tsrt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tstr">
<h3><a class="doc-anchor" href="#doc-tstr">#</a> <code>tstr</code></h3>
<p><code>tstr</code> — misc / utility builtin. Alias for <code>to_string_val</code>.</p>
<pre><code class="lang-perl">my $result = tstr $x
# or in a pipeline:
@list |> map tstr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ttable">
<h3><a class="doc-anchor" href="#doc-ttable">#</a> <code>ttable</code></h3>
<p><code>ttable</code> — algorithms / puzzles builtin. Alias for <code>truth_table</code>.</p>
<pre><code class="lang-perl">my $result = ttable $x
# or in a pipeline:
@list |> map ttable |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tvals">
<h3><a class="doc-anchor" href="#doc-tvals">#</a> <code>tvals</code></h3>
<p><code>tvals</code> — python/ruby stdlib builtin. Alias for <code>transform_values</code>.</p>
<pre><code class="lang-perl">my $result = tvals $x
# or in a pipeline:
@list |> map tvals |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-twin-primes">
<h3><a class="doc-anchor" href="#doc-twin-primes">#</a> <code>twin_primes</code></h3>
<p><code>twin_primes</code> — number theory / primes builtin.</p>
<pre><code class="lang-perl">my $result = twin_primes $x
# or in a pipeline:
@list |> map twin_primes |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-twinp">
<h3><a class="doc-anchor" href="#doc-twinp">#</a> <code>twinp</code></h3>
<p><code>twinp</code> — number theory / primes builtin. Alias for <code>twin_primes</code>.</p>
<pre><code class="lang-perl">my $result = twinp $x
# or in a pipeline:
@list |> map twinp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-txaft">
<h3><a class="doc-anchor" href="#doc-txaft">#</a> <code>txaft</code></h3>
<p><code>txaft</code> — extended stdlib builtin. Alias for <code>text_after</code>.</p>
<pre><code class="lang-perl">my $result = txaft $x
# or in a pipeline:
@list |> map txaft |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-txaftl">
<h3><a class="doc-anchor" href="#doc-txaftl">#</a> <code>txaftl</code></h3>
<p><code>txaftl</code> — extended stdlib builtin. Alias for <code>text_after_last</code>.</p>
<pre><code class="lang-perl">my $result = txaftl $x
# or in a pipeline:
@list |> map txaftl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-txbef">
<h3><a class="doc-anchor" href="#doc-txbef">#</a> <code>txbef</code></h3>
<p><code>txbef</code> — extended stdlib builtin. Alias for <code>text_before</code>.</p>
<pre><code class="lang-perl">my $result = txbef $x
# or in a pipeline:
@list |> map txbef |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-txbefl">
<h3><a class="doc-anchor" href="#doc-txbefl">#</a> <code>txbefl</code></h3>
<p><code>txbefl</code> — extended stdlib builtin. Alias for <code>text_before_last</code>.</p>
<pre><code class="lang-perl">my $result = txbefl $x
# or in a pipeline:
@list |> map txbefl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-txbtwn">
<h3><a class="doc-anchor" href="#doc-txbtwn">#</a> <code>txbtwn</code></h3>
<p><code>txbtwn</code> — extended stdlib builtin. Alias for <code>text_between</code>.</p>
<pre><code class="lang-perl">my $result = txbtwn $x
# or in a pipeline:
@list |> map txbtwn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-type-each">
<h3><a class="doc-anchor" href="#doc-type-each">#</a> <code>type_each</code></h3>
<p><code>type_each</code> — trivial numeric helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = type_each $x
# or in a pipeline:
@list |> map type_each |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-type-of">
<h3><a class="doc-anchor" href="#doc-type-of">#</a> <code>type_of</code></h3>
<p><code>type_of</code> — misc / utility builtin.</p>
<pre><code class="lang-perl">my $result = type_of $x
# or in a pipeline:
@list |> map type_of |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-typeof">
<h3><a class="doc-anchor" href="#doc-typeof">#</a> <code>typeof</code></h3>
<p><code>typeof</code> — misc / utility builtin. Alias for <code>type_of</code>.</p>
<pre><code class="lang-perl">my $result = typeof $x
# or in a pipeline:
@list |> map typeof |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-tz">
<h3><a class="doc-anchor" href="#doc-tz">#</a> <code>tz</code></h3>
<p><code>tz</code> — base conversion builtin. Alias for <code>trailing_zeros</code>.</p>
<pre><code class="lang-perl">my $result = tz $x
# or in a pipeline:
@list |> map tz |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ubound">
<h3><a class="doc-anchor" href="#doc-ubound">#</a> <code>ubound</code></h3>
<p><code>ubound</code> — extended stdlib builtin. Alias for <code>upper_bound</code>.</p>
<pre><code class="lang-perl">my $result = ubound $x
# or in a pipeline:
@list |> map ubound |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ud">
<h3><a class="doc-anchor" href="#doc-ud">#</a> <code>ud</code></h3>
<p><code>ud</code> — crypto / encoding builtin. Alias for <code>url_decode</code>.</p>
<pre><code class="lang-perl">my $result = ud $x
# or in a pipeline:
@list |> map ud |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ue">
<h3><a class="doc-anchor" href="#doc-ue">#</a> <code>ue</code></h3>
<p><code>ue</code> — crypto / encoding builtin. Alias for <code>url_encode</code>.</p>
<pre><code class="lang-perl">my $result = ue $x
# or in a pipeline:
@list |> map ue |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ugz">
<h3><a class="doc-anchor" href="#doc-ugz">#</a> <code>ugz</code></h3>
<p><code>ugz</code> — crypto / encoding builtin. Alias for <code>gunzip</code>.</p>
<pre><code class="lang-perl">my $result = ugz $x
# or in a pipeline:
@list |> map ugz |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-uid">
<h3><a class="doc-anchor" href="#doc-uid">#</a> <code>uid</code></h3>
<p><code>uid</code> — system introspection builtin.</p>
<pre><code class="lang-perl">my $result = uid $x
# or in a pipeline:
@list |> map uid |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-uin">
<h3><a class="doc-anchor" href="#doc-uin">#</a> <code>uin</code></h3>
<p><code>uin</code> — algebraic match builtin. Alias for <code>update_in</code>.</p>
<pre><code class="lang-perl">my $result = uin $x
# or in a pipeline:
@list |> map uin |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-undef-count">
<h3><a class="doc-anchor" href="#doc-undef-count">#</a> <code>undef_count</code></h3>
<p><code>undef_count</code> — counters (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = undef_count $x
# or in a pipeline:
@list |> map undef_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-underline">
<h3><a class="doc-anchor" href="#doc-underline">#</a> <code>underline</code></h3>
<p><code>underline</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = underline $x
# or in a pipeline:
@list |> map underline |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-unfold">
<h3><a class="doc-anchor" href="#doc-unfold">#</a> <code>unfold</code></h3>
<p><code>unfold</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = unfold $x
# or in a pipeline:
@list |> map unfold |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-unfoldr">
<h3><a class="doc-anchor" href="#doc-unfoldr">#</a> <code>unfoldr</code></h3>
<p><code>unfoldr</code> — haskell list functions builtin.</p>
<pre><code class="lang-perl">my $result = unfoldr $x
# or in a pipeline:
@list |> map unfoldr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-unfr">
<h3><a class="doc-anchor" href="#doc-unfr">#</a> <code>unfr</code></h3>
<p><code>unfr</code> — haskell list functions builtin. Alias for <code>unfoldr</code>.</p>
<pre><code class="lang-perl">my $result = unfr $x
# or in a pipeline:
@list |> map unfr |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-union-list">
<h3><a class="doc-anchor" href="#doc-union-list">#</a> <code>union_list</code></h3>
<p><code>union_list</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = union_list $x
# or in a pipeline:
@list |> map union_list |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-unionl">
<h3><a class="doc-anchor" href="#doc-unionl">#</a> <code>unionl</code></h3>
<p><code>unionl</code> — additional missing stdlib functions builtin. Alias for <code>union_list</code>.</p>
<pre><code class="lang-perl">my $result = unionl $x
# or in a pipeline:
@list |> map unionl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-uniq-by">
<h3><a class="doc-anchor" href="#doc-uniq-by">#</a> <code>uniq_by</code></h3>
<p><code>uniq_by</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = uniq_by $x
# or in a pipeline:
@list |> map uniq_by |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-unique-count-of">
<h3><a class="doc-anchor" href="#doc-unique-count-of">#</a> <code>unique_count_of</code></h3>
<p><code>unique_count_of</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = unique_count_of $x
# or in a pipeline:
@list |> map unique_count_of |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-unique-words">
<h3><a class="doc-anchor" href="#doc-unique-words">#</a> <code>unique_words</code></h3>
<p><code>unique_words</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = unique_words $x
# or in a pipeline:
@list |> map unique_words |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-uniqw">
<h3><a class="doc-anchor" href="#doc-uniqw">#</a> <code>uniqw</code></h3>
<p><code>uniqw</code> — string processing (uncategorized batch) builtin. Alias for <code>unique_words</code>.</p>
<pre><code class="lang-perl">my $result = uniqw $x
# or in a pipeline:
@list |> map uniqw |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-unit-vec">
<h3><a class="doc-anchor" href="#doc-unit-vec">#</a> <code>unit_vec</code></h3>
<p><code>unit_vec</code> — matrix / linear algebra builtin. Alias for <code>vec_normalize</code>.</p>
<pre><code class="lang-perl">my $result = unit_vec $x
# or in a pipeline:
@list |> map unit_vec |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-unix-epoch">
<h3><a class="doc-anchor" href="#doc-unix-epoch">#</a> <code>unix_epoch</code></h3>
<p><code>unix_epoch</code> — now / timestamp builtin.</p>
<pre><code class="lang-perl">my $result = unix_epoch $x
# or in a pipeline:
@list |> map unix_epoch |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-unix-epoch-ms">
<h3><a class="doc-anchor" href="#doc-unix-epoch-ms">#</a> <code>unix_epoch_ms</code></h3>
<p><code>unix_epoch_ms</code> — now / timestamp builtin.</p>
<pre><code class="lang-perl">my $result = unix_epoch_ms $x
# or in a pipeline:
@list |> map unix_epoch_ms |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-unlines">
<h3><a class="doc-anchor" href="#doc-unlines">#</a> <code>unlines</code></h3>
<p><code>unlines</code> — go/general functional utilities builtin.</p>
<pre><code class="lang-perl">my $result = unlines $x
# or in a pipeline:
@list |> map unlines |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-unlns">
<h3><a class="doc-anchor" href="#doc-unlns">#</a> <code>unlns</code></h3>
<p><code>unlns</code> — go/general functional utilities builtin. Alias for <code>unlines</code>.</p>
<pre><code class="lang-perl">my $result = unlns $x
# or in a pipeline:
@list |> map unlns |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-unquote">
<h3><a class="doc-anchor" href="#doc-unquote">#</a> <code>unquote</code></h3>
<p><code>unquote</code> — string quote / escape builtin.</p>
<pre><code class="lang-perl">my $result = unquote $x
# or in a pipeline:
@list |> map unquote |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-untie">
<h3><a class="doc-anchor" href="#doc-untie">#</a> <code>untie</code></h3>
<p><code>untie</code> — type / reflection builtin.</p>
<pre><code class="lang-perl">my $result = untie $x
# or in a pipeline:
@list |> map untie |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-unwds">
<h3><a class="doc-anchor" href="#doc-unwds">#</a> <code>unwds</code></h3>
<p><code>unwds</code> — go/general functional utilities builtin. Alias for <code>unwords</code>.</p>
<pre><code class="lang-perl">my $result = unwds $x
# or in a pipeline:
@list |> map unwds |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-unwords">
<h3><a class="doc-anchor" href="#doc-unwords">#</a> <code>unwords</code></h3>
<p><code>unwords</code> — go/general functional utilities builtin.</p>
<pre><code class="lang-perl">my $result = unwords $x
# or in a pipeline:
@list |> map unwords |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-unzip">
<h3><a class="doc-anchor" href="#doc-unzip">#</a> <code>unzip</code></h3>
<p><code>unzip</code> — collection more builtin.</p>
<pre><code class="lang-perl">my $result = unzip $x
# or in a pipeline:
@list |> map unzip |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-unzip-archive">
<h3><a class="doc-anchor" href="#doc-unzip-archive">#</a> <code>unzip_archive</code></h3>
<p><code>unzip_archive</code> — crypto / encoding builtin. Alias for <code>zip_extract</code>.</p>
<pre><code class="lang-perl">my $result = unzip_archive $x
# or in a pipeline:
@list |> map unzip_archive |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-unzip-pairs">
<h3><a class="doc-anchor" href="#doc-unzip-pairs">#</a> <code>unzip_pairs</code></h3>
<p><code>unzip_pairs</code> — go/general functional utilities builtin.</p>
<pre><code class="lang-perl">my $result = unzip_pairs $x
# or in a pipeline:
@list |> map unzip_pairs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-upcase-each">
<h3><a class="doc-anchor" href="#doc-upcase-each">#</a> <code>upcase_each</code></h3>
<p><code>upcase_each</code> — trivial numeric helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = upcase_each $x
# or in a pipeline:
@list |> map upcase_each |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-upda">
<h3><a class="doc-anchor" href="#doc-upda">#</a> <code>upda</code></h3>
<p><code>upda</code> — go/general functional utilities builtin. Alias for <code>update_at</code>.</p>
<pre><code class="lang-perl">my $result = upda $x
# or in a pipeline:
@list |> map upda |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-update-at">
<h3><a class="doc-anchor" href="#doc-update-at">#</a> <code>update_at</code></h3>
<p><code>update_at</code> — go/general functional utilities builtin.</p>
<pre><code class="lang-perl">my $result = update_at $x
# or in a pipeline:
@list |> map update_at |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-update-in">
<h3><a class="doc-anchor" href="#doc-update-in">#</a> <code>update_in</code></h3>
<p><code>update_in</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = update_in $x
# or in a pipeline:
@list |> map update_in |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-upper-bound">
<h3><a class="doc-anchor" href="#doc-upper-bound">#</a> <code>upper_bound</code></h3>
<p><code>upper_bound</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = upper_bound $x
# or in a pipeline:
@list |> map upper_bound |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-upper-snake">
<h3><a class="doc-anchor" href="#doc-upper-snake">#</a> <code>upper_snake</code></h3>
<p><code>upper_snake</code> — string (batch 2) builtin. Alias for <code>constant_case</code>.</p>
<pre><code class="lang-perl">my $result = upper_snake $x
# or in a pipeline:
@list |> map upper_snake |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-uppercase">
<h3><a class="doc-anchor" href="#doc-uppercase">#</a> <code>uppercase</code></h3>
<p><code>uppercase</code> — string (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = uppercase $x
# or in a pipeline:
@list |> map uppercase |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-upsample">
<h3><a class="doc-anchor" href="#doc-upsample">#</a> <code>upsample</code></h3>
<p><code>upsample(\@signal, $factor)</code> (alias <code>interpolate</code>) — increases sample rate by inserting zeros and filtering. Factor must be positive integer.</p>
<pre><code class="lang-perl">my $upsampled = interpolate(\@signal, 4) # 4x sample rate
</code></pre>
</article>
<article class="doc-entry" id="doc-uptime-secs">
<h3><a class="doc-anchor" href="#doc-uptime-secs">#</a> <code>uptime_secs</code></h3>
<p><code>uptime_secs</code> — more process / system builtin.</p>
<pre><code class="lang-perl">my $result = uptime_secs $x
# or in a pipeline:
@list |> map uptime_secs |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-upto">
<h3><a class="doc-anchor" href="#doc-upto">#</a> <code>upto</code></h3>
<p><code>upto</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = upto $x
# or in a pipeline:
@list |> map upto |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-uqb">
<h3><a class="doc-anchor" href="#doc-uqb">#</a> <code>uqb</code></h3>
<p><code>uqb</code> — python/ruby stdlib builtin. Alias for <code>uniq_by</code>.</p>
<pre><code class="lang-perl">my $result = uqb $x
# or in a pipeline:
@list |> map uqb |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-url-host">
<h3><a class="doc-anchor" href="#doc-url-host">#</a> <code>url_host</code></h3>
<p><code>url_host</code> — url / email parts builtin.</p>
<pre><code class="lang-perl">my $result = url_host $x
# or in a pipeline:
@list |> map url_host |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-url-path">
<h3><a class="doc-anchor" href="#doc-url-path">#</a> <code>url_path</code></h3>
<p><code>url_path</code> — url / email parts builtin.</p>
<pre><code class="lang-perl">my $result = url_path $x
# or in a pipeline:
@list |> map url_path |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-url-query">
<h3><a class="doc-anchor" href="#doc-url-query">#</a> <code>url_query</code></h3>
<p><code>url_query</code> — url / email parts builtin.</p>
<pre><code class="lang-perl">my $result = url_query $x
# or in a pipeline:
@list |> map url_query |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-url-scheme">
<h3><a class="doc-anchor" href="#doc-url-scheme">#</a> <code>url_scheme</code></h3>
<p><code>url_scheme</code> — url / email parts builtin.</p>
<pre><code class="lang-perl">my $result = url_scheme $x
# or in a pipeline:
@list |> map url_scheme |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-urld">
<h3><a class="doc-anchor" href="#doc-urld">#</a> <code>urld</code></h3>
<p><code>urld</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = urld $x
# or in a pipeline:
@list |> map urld |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-urle">
<h3><a class="doc-anchor" href="#doc-urle">#</a> <code>urle</code></h3>
<p><code>urle</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = urle $x
# or in a pipeline:
@list |> map urle |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-us-to-ns">
<h3><a class="doc-anchor" href="#doc-us-to-ns">#</a> <code>us_to_ns</code></h3>
<p><code>us_to_ns</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = us_to_ns $input
</code></pre>
</article>
<article class="doc-entry" id="doc-usamp">
<h3><a class="doc-anchor" href="#doc-usamp">#</a> <code>usamp</code></h3>
<p><code>usamp</code> — dsp / signal (extended) builtin. Alias for <code>upsample</code>.</p>
<pre><code class="lang-perl">my $result = usamp $x
# or in a pipeline:
@list |> map usamp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-username">
<h3><a class="doc-anchor" href="#doc-username">#</a> <code>username</code></h3>
<p><code>username</code> — system introspection builtin.</p>
<pre><code class="lang-perl">my $result = username $x
# or in a pipeline:
@list |> map username |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-utc">
<h3><a class="doc-anchor" href="#doc-utc">#</a> <code>utc</code></h3>
<p><code>utc</code> — date / time builtin. Alias for <code>datetime_utc</code>.</p>
<pre><code class="lang-perl">my $result = utc $x
# or in a pipeline:
@list |> map utc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-uuid-v4">
<h3><a class="doc-anchor" href="#doc-uuid-v4">#</a> <code>uuid_v4</code></h3>
<p><code>uuid_v4</code> — id helpers builtin.</p>
<pre><code class="lang-perl">my $result = uuid_v4 $x
# or in a pipeline:
@list |> map uuid_v4 |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-uzp">
<h3><a class="doc-anchor" href="#doc-uzp">#</a> <code>uzp</code></h3>
<p><code>uzp</code> — go/general functional utilities builtin. Alias for <code>unzip_pairs</code>.</p>
<pre><code class="lang-perl">my $result = uzp $x
# or in a pipeline:
@list |> map uzp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-uzst">
<h3><a class="doc-anchor" href="#doc-uzst">#</a> <code>uzst</code></h3>
<p><code>uzst</code> — crypto / encoding builtin. Alias for <code>zstd_decode</code>.</p>
<pre><code class="lang-perl">my $result = uzst $x
# or in a pipeline:
@list |> map uzst |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-vacuum-permeability">
<h3><a class="doc-anchor" href="#doc-vacuum-permeability">#</a> <code>vacuum_permeability</code></h3>
<p><code>vacuum_permeability</code> — physics constants builtin.</p>
<pre><code class="lang-perl">my $result = vacuum_permeability $x
# or in a pipeline:
@list |> map vacuum_permeability |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-values-at">
<h3><a class="doc-anchor" href="#doc-values-at">#</a> <code>values_at</code></h3>
<p><code>values_at</code> — python/ruby stdlib builtin.</p>
<pre><code class="lang-perl">my $result = values_at $x
# or in a pipeline:
@list |> map values_at |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-values-sorted">
<h3><a class="doc-anchor" href="#doc-values-sorted">#</a> <code>values_sorted</code></h3>
<p><code>values_sorted</code> — hash ops (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = values_sorted $x
# or in a pipeline:
@list |> map values_sorted |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-vang">
<h3><a class="doc-anchor" href="#doc-vang">#</a> <code>vang</code></h3>
<p><code>vang</code> — geometry (extended) builtin. Alias for <code>vector_angle</code>.</p>
<pre><code class="lang-perl">my $result = vang $x
# or in a pipeline:
@list |> map vang |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-vat">
<h3><a class="doc-anchor" href="#doc-vat">#</a> <code>vat</code></h3>
<p><code>vat</code> — python/ruby stdlib builtin. Alias for <code>values_at</code>.</p>
<pre><code class="lang-perl">my $result = vat $x
# or in a pipeline:
@list |> map vat |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-vcross">
<h3><a class="doc-anchor" href="#doc-vcross">#</a> <code>vcross</code></h3>
<p><code>vector_cross(\@a, \@b)</code> (alias <code>vcross</code>) — computes the cross product of two 3D vectors. Returns a 3-element arrayref perpendicular to both inputs.</p>
<pre><code class="lang-perl">my $c = vcross([1,0,0], [0,1,0])
p @$c # (0, 0, 1)
</code></pre>
</article>
<article class="doc-entry" id="doc-vdot">
<h3><a class="doc-anchor" href="#doc-vdot">#</a> <code>vdot</code></h3>
<p><code>vector_dot(\@a, \@b)</code> (alias <code>vdot</code>) — computes the dot product of two vectors. Returns the scalar sum of element-wise products.</p>
<pre><code class="lang-perl">p vdot([1,2,3], [4,5,6]) # 32
</code></pre>
</article>
<article class="doc-entry" id="doc-vec-add">
<h3><a class="doc-anchor" href="#doc-vec-add">#</a> <code>vec_add</code></h3>
<p><code>vec_add</code> — matrix / linear algebra builtin.</p>
<pre><code class="lang-perl">my $result = vec_add $x
# or in a pipeline:
@list |> map vec_add |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-vec-clj">
<h3><a class="doc-anchor" href="#doc-vec-clj">#</a> <code>vec_clj</code></h3>
<p><code>vec_clj</code> — algebraic match builtin.</p>
<pre><code class="lang-perl">my $result = vec_clj $x
# or in a pipeline:
@list |> map vec_clj |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-vec-normalize">
<h3><a class="doc-anchor" href="#doc-vec-normalize">#</a> <code>vec_normalize</code></h3>
<p><code>vec_normalize</code> — matrix / linear algebra builtin.</p>
<pre><code class="lang-perl">my $result = vec_normalize $x
# or in a pipeline:
@list |> map vec_normalize |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-vec-scale">
<h3><a class="doc-anchor" href="#doc-vec-scale">#</a> <code>vec_scale</code></h3>
<p><code>vec_scale</code> — matrix / linear algebra builtin.</p>
<pre><code class="lang-perl">my $result = vec_scale $x
# or in a pipeline:
@list |> map vec_scale |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-vec-sub">
<h3><a class="doc-anchor" href="#doc-vec-sub">#</a> <code>vec_sub</code></h3>
<p><code>vec_sub</code> — matrix / linear algebra builtin.</p>
<pre><code class="lang-perl">my $result = vec_sub $x
# or in a pipeline:
@list |> map vec_sub |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-vecc">
<h3><a class="doc-anchor" href="#doc-vecc">#</a> <code>vecc</code></h3>
<p><code>vecc</code> — algebraic match builtin. Alias for <code>vec_clj</code>.</p>
<pre><code class="lang-perl">my $result = vecc $x
# or in a pipeline:
@list |> map vecc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-vector-angle">
<h3><a class="doc-anchor" href="#doc-vector-angle">#</a> <code>vector_angle</code></h3>
<p><code>vector_angle(\@a, \@b)</code> (alias <code>vangle</code>) — computes the angle in radians between two vectors using the dot product formula.</p>
<pre><code class="lang-perl">p vangle([1,0], [0,1]) # ~1.5708 (π/2)
p vangle([1,0], [1,0]) # 0
</code></pre>
</article>
<article class="doc-entry" id="doc-vector-magnitude">
<h3><a class="doc-anchor" href="#doc-vector-magnitude">#</a> <code>vector_magnitude</code></h3>
<p><code>vector_magnitude(\@v)</code> (alias <code>vmag</code>) — computes the Euclidean length (L2 norm) of a vector.</p>
<pre><code class="lang-perl">p vmag([3, 4]) # 5
p vmag([1, 2, 2]) # 3
</code></pre>
</article>
<article class="doc-entry" id="doc-vector-normalize">
<h3><a class="doc-anchor" href="#doc-vector-normalize">#</a> <code>vector_normalize</code></h3>
<p><code>vector_normalize(\@v)</code> (alias <code>vnorm</code>) — returns a unit vector in the same direction. Divides by magnitude.</p>
<pre><code class="lang-perl">my $u = vnorm([3, 4])
p @$u # (0.6, 0.8)
</code></pre>
</article>
<article class="doc-entry" id="doc-versin">
<h3><a class="doc-anchor" href="#doc-versin">#</a> <code>versin</code></h3>
<p><code>versin</code> — trig extensions builtin.</p>
<pre><code class="lang-perl">my $result = versin $x
# or in a pipeline:
@list |> map versin |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-versine">
<h3><a class="doc-anchor" href="#doc-versine">#</a> <code>versine</code></h3>
<p><code>versine</code> — trig extensions builtin. Alias for <code>versin</code>.</p>
<pre><code class="lang-perl">my $result = versine $x
# or in a pipeline:
@list |> map versine |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-version-cmp">
<h3><a class="doc-anchor" href="#doc-version-cmp">#</a> <code>version_cmp</code></h3>
<p><code>version_cmp</code> — file stat / path builtin. Alias for <code>compare_versions</code>.</p>
<pre><code class="lang-perl">my $result = version_cmp $x
# or in a pipeline:
@list |> map version_cmp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-void">
<h3><a class="doc-anchor" href="#doc-void">#</a> <code>void</code></h3>
<p><code>void</code> — conversion / utility (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = void $x
# or in a pipeline:
@list |> map void |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wacc">
<h3><a class="doc-anchor" href="#doc-wacc">#</a> <code>wacc</code></h3>
<p><code>wacc($equity, $debt, $cost_equity, $cost_debt, $tax_rate)</code> — computes Weighted Average Cost of Capital. Returns the blended cost of capital accounting for the tax shield on debt.</p>
<pre><code class="lang-perl">p wacc(60, 40, 0.10, 0.05, 0.25) # ~7.5%
</code></pre>
</article>
<article class="doc-entry" id="doc-watts-to-hp">
<h3><a class="doc-anchor" href="#doc-watts-to-hp">#</a> <code>watts_to_hp</code></h3>
<p><code>watts_to_hp</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = watts_to_hp $input
</code></pre>
</article>
<article class="doc-entry" id="doc-wavelength-freq">
<h3><a class="doc-anchor" href="#doc-wavelength-freq">#</a> <code>wavelength_freq</code></h3>
<p><code>wavelength_freq</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = wavelength_freq $x
# or in a pipeline:
@list |> map wavelength_freq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wc">
<h3><a class="doc-anchor" href="#doc-wc">#</a> <code>wc</code></h3>
<p><code>wc</code> — trivial string ops builtin. Alias for <code>word_count</code>.</p>
<pre><code class="lang-perl">my $result = wc $x
# or in a pipeline:
@list |> map wc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wcount">
<h3><a class="doc-anchor" href="#doc-wcount">#</a> <code>wcount</code></h3>
<p><code>wcount</code> — extended stdlib batch 3 builtin. Alias for <code>count_words</code>.</p>
<pre><code class="lang-perl">my $result = wcount $x
# or in a pipeline:
@list |> map wcount |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-week-of-year">
<h3><a class="doc-anchor" href="#doc-week-of-year">#</a> <code>week_of_year</code></h3>
<p><code>week_of_year</code> — extended stdlib batch 3 builtin.</p>
<pre><code class="lang-perl">my $result = week_of_year $x
# or in a pipeline:
@list |> map week_of_year |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-weekday-name">
<h3><a class="doc-anchor" href="#doc-weekday-name">#</a> <code>weekday_name</code></h3>
<p><code>weekday_name</code> — date helpers builtin.</p>
<pre><code class="lang-perl">my $result = weekday_name $x
# or in a pipeline:
@list |> map weekday_name |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-weekday-short">
<h3><a class="doc-anchor" href="#doc-weekday-short">#</a> <code>weekday_short</code></h3>
<p><code>weekday_short</code> — date helpers builtin.</p>
<pre><code class="lang-perl">my $result = weekday_short $x
# or in a pipeline:
@list |> map weekday_short |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-weibpdf">
<h3><a class="doc-anchor" href="#doc-weibpdf">#</a> <code>weibpdf</code></h3>
<p><code>weibull_pdf</code> (alias <code>weibpdf</code>) evaluates the Weibull distribution PDF at x with shape k and scale lambda.</p>
<pre><code class="lang-perl">p weibpdf(1.0, 1.5, 1.0)
</code></pre>
</article>
<article class="doc-entry" id="doc-weighted-mean">
<h3><a class="doc-anchor" href="#doc-weighted-mean">#</a> <code>weighted_mean</code></h3>
<p><code>weighted_mean</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = weighted_mean $x
# or in a pipeline:
@list |> map weighted_mean |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-weighted-sample">
<h3><a class="doc-anchor" href="#doc-weighted-sample">#</a> <code>weighted_sample</code></h3>
<p><code>weighted_sample</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = weighted_sample $x
# or in a pipeline:
@list |> map weighted_sample |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-weighted-var">
<h3><a class="doc-anchor" href="#doc-weighted-var">#</a> <code>weighted_var</code></h3>
<p><code>weighted_var</code> — weighted variance. Args: values, weights.</p>
<pre><code class="lang-perl">p wvar([1,2,3,4], [1,1,1,1]) # same as var
</code></pre>
</article>
<article class="doc-entry" id="doc-welch-ttest">
<h3><a class="doc-anchor" href="#doc-welch-ttest">#</a> <code>welch_ttest</code></h3>
<p><code>welch_ttest</code> (alias <code>welcht</code>) performs Welch's t-test for two independent samples with unequal variances. Returns [t-statistic, degrees of freedom].</p>
<pre><code class="lang-perl">my ($t, $df) = @{welcht([1,2,3,4,5], [3,4,5,6,7])}
p "t=$t df=$df"
</code></pre>
</article>
<article class="doc-entry" id="doc-wfrm">
<h3><a class="doc-anchor" href="#doc-wfrm">#</a> <code>wfrm</code></h3>
<p><code>wfrm</code> — go/general functional utilities builtin. Alias for <code>words_from</code>.</p>
<pre><code class="lang-perl">my $result = wfrm $x
# or in a pipeline:
@list |> map wfrm |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wh">
<h3><a class="doc-anchor" href="#doc-wh">#</a> <code>wh</code></h3>
<p><code>wh</code> — filesystem extensions builtin. Alias for <code>which</code>.</p>
<pre><code class="lang-perl">my $result = wh $x
# or in a pipeline:
@list |> map wh |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wha">
<h3><a class="doc-anchor" href="#doc-wha">#</a> <code>wha</code></h3>
<p>Return a list of all absolute paths matching the given command name across every directory in <code>PATH</code>, not just the first match. The short alias <code>wha</code> keeps things concise. This is useful for detecting shadowed executables or auditing which versions of a tool are installed.</p>
<pre><code class="lang-perl">my @all = which_all("python3")
@all |> e p # /usr/local/bin/python3
# /usr/bin/python3
p scalar wha("perl") # number of perls on PATH
</code></pre>
</article>
<article class="doc-entry" id="doc-when-false">
<h3><a class="doc-anchor" href="#doc-when-false">#</a> <code>when_false</code></h3>
<p><code>when_false</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = when_false $x
# or in a pipeline:
@list |> map when_false |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-when-true">
<h3><a class="doc-anchor" href="#doc-when-true">#</a> <code>when_true</code></h3>
<p><code>when_true</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = when_true $x
# or in a pipeline:
@list |> map when_true |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-which-fn">
<h3><a class="doc-anchor" href="#doc-which-fn">#</a> <code>which_fn</code></h3>
<p><code>which_fn</code> — return indices where a predicate is true. Like R's which().</p>
<pre><code class="lang-perl">my @idx = @{which_fn([1,5,3,8,2], fn { $_[0] > 3 })} # [1, 3]
</code></pre>
</article>
<article class="doc-entry" id="doc-white">
<h3><a class="doc-anchor" href="#doc-white">#</a> <code>white</code></h3>
<p><code>white</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = white $x
# or in a pipeline:
@list |> map white |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-white-bold">
<h3><a class="doc-anchor" href="#doc-white-bold">#</a> <code>white_bold</code></h3>
<p><code>white_bold</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = white_bold $x
# or in a pipeline:
@list |> map white_bold |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wien">
<h3><a class="doc-anchor" href="#doc-wien">#</a> <code>wien</code></h3>
<p><code>wien</code> — physics formulas builtin. Alias for <code>wien_displacement</code>.</p>
<pre><code class="lang-perl">my $result = wien $x
# or in a pipeline:
@list |> map wien |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wien-constant">
<h3><a class="doc-anchor" href="#doc-wien-constant">#</a> <code>wien_constant</code></h3>
<p><code>wien_constant</code> — physics constants builtin.</p>
<pre><code class="lang-perl">my $result = wien_constant $x
# or in a pipeline:
@list |> map wien_constant |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wien-displacement">
<h3><a class="doc-anchor" href="#doc-wien-displacement">#</a> <code>wien_displacement</code></h3>
<p><code>wien_displacement</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = wien_displacement $x
# or in a pipeline:
@list |> map wien_displacement |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wincirc">
<h3><a class="doc-anchor" href="#doc-wincirc">#</a> <code>wincirc</code></h3>
<p><code>wincirc</code> — additional missing stdlib functions builtin. Alias for <code>windowed_circular</code>.</p>
<pre><code class="lang-perl">my $result = wincirc $x
# or in a pipeline:
@list |> map wincirc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wind-chill">
<h3><a class="doc-anchor" href="#doc-wind-chill">#</a> <code>wind_chill</code></h3>
<p><code>wind_chill</code> — physics formulas builtin.</p>
<pre><code class="lang-perl">my $result = wind_chill $x
# or in a pipeline:
@list |> map wind_chill |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-window-n">
<h3><a class="doc-anchor" href="#doc-window-n">#</a> <code>window_n</code></h3>
<p><code>window_n</code> — go/general functional utilities builtin.</p>
<pre><code class="lang-perl">my $result = window_n $x
# or in a pipeline:
@list |> map window_n |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-windowed-circular">
<h3><a class="doc-anchor" href="#doc-windowed-circular">#</a> <code>windowed_circular</code></h3>
<p><code>windowed_circular</code> — additional missing stdlib functions builtin.</p>
<pre><code class="lang-perl">my $result = windowed_circular $x
# or in a pipeline:
@list |> map windowed_circular |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-winn">
<h3><a class="doc-anchor" href="#doc-winn">#</a> <code>winn</code></h3>
<p><code>winn</code> — go/general functional utilities builtin. Alias for <code>window_n</code>.</p>
<pre><code class="lang-perl">my $result = winn $x
# or in a pipeline:
@list |> map winn |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-winsor">
<h3><a class="doc-anchor" href="#doc-winsor">#</a> <code>winsor</code></h3>
<p><code>winsor</code> — math / numeric (uncategorized batch) builtin. Alias for <code>winsorize</code>.</p>
<pre><code class="lang-perl">my $result = winsor $x
# or in a pipeline:
@list |> map winsor |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-winsorize">
<h3><a class="doc-anchor" href="#doc-winsorize">#</a> <code>winsorize</code></h3>
<p><code>winsorize</code> — math / numeric (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = winsorize $x
# or in a pipeline:
@list |> map winsorize |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-without">
<h3><a class="doc-anchor" href="#doc-without">#</a> <code>without</code></h3>
<p><code>without</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = without $x
# or in a pipeline:
@list |> map without |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-without-nth">
<h3><a class="doc-anchor" href="#doc-without-nth">#</a> <code>without_nth</code></h3>
<p><code>without_nth</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = without_nth $x
# or in a pipeline:
@list |> map without_nth |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wmean">
<h3><a class="doc-anchor" href="#doc-wmean">#</a> <code>wmean</code></h3>
<p><code>wmean</code> — math / numeric (uncategorized batch) builtin. Alias for <code>weighted_mean</code>.</p>
<pre><code class="lang-perl">my $result = wmean $x
# or in a pipeline:
@list |> map wmean |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-word-count">
<h3><a class="doc-anchor" href="#doc-word-count">#</a> <code>word_count</code></h3>
<p><code>word_count</code> — trivial string ops builtin.</p>
<pre><code class="lang-perl">my $result = word_count $x
# or in a pipeline:
@list |> map word_count |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-word-frequencies">
<h3><a class="doc-anchor" href="#doc-word-frequencies">#</a> <code>word_frequencies</code></h3>
<p><code>word_frequencies</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = word_frequencies $x
# or in a pipeline:
@list |> map word_frequencies |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-word-wrap-text">
<h3><a class="doc-anchor" href="#doc-word-wrap-text">#</a> <code>word_wrap_text</code></h3>
<p><code>word_wrap_text</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = word_wrap_text $x
# or in a pipeline:
@list |> map word_wrap_text |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wordfreq">
<h3><a class="doc-anchor" href="#doc-wordfreq">#</a> <code>wordfreq</code></h3>
<p><code>wordfreq</code> — string processing (uncategorized batch) builtin. Alias for <code>word_frequencies</code>.</p>
<pre><code class="lang-perl">my $result = wordfreq $x
# or in a pipeline:
@list |> map wordfreq |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-words-from">
<h3><a class="doc-anchor" href="#doc-words-from">#</a> <code>words_from</code></h3>
<p><code>words_from</code> — go/general functional utilities builtin.</p>
<pre><code class="lang-perl">my $result = words_from $x
# or in a pipeline:
@list |> map words_from |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-work">
<h3><a class="doc-anchor" href="#doc-work">#</a> <code>work</code></h3>
<p><code>work($force, $distance, $angle)</code> — compute work W = F×d×cos(θ) (Joules). Angle in degrees, default 0.</p>
<pre><code class="lang-perl">p work(100, 10) # 1000 J (force parallel to motion)
p work(100, 10, 60) # 500 J (force at 60°)
</code></pre>
</article>
<article class="doc-entry" id="doc-woy">
<h3><a class="doc-anchor" href="#doc-woy">#</a> <code>woy</code></h3>
<p><code>woy</code> — extended stdlib batch 3 builtin. Alias for <code>week_of_year</code>.</p>
<pre><code class="lang-perl">my $result = woy $x
# or in a pipeline:
@list |> map woy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wrap-around">
<h3><a class="doc-anchor" href="#doc-wrap-around">#</a> <code>wrap_around</code></h3>
<p><code>wrap_around</code> — trig / math (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = wrap_around $x
# or in a pipeline:
@list |> map wrap_around |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wrap-index">
<h3><a class="doc-anchor" href="#doc-wrap-index">#</a> <code>wrap_index</code></h3>
<p><code>wrap_index</code> — list helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = wrap_index $x
# or in a pipeline:
@list |> map wrap_index |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wrap-range">
<h3><a class="doc-anchor" href="#doc-wrap-range">#</a> <code>wrap_range</code></h3>
<p><code>wrap_range</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = wrap_range $x
# or in a pipeline:
@list |> map wrap_range |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wrap-text">
<h3><a class="doc-anchor" href="#doc-wrap-text">#</a> <code>wrap_text</code></h3>
<p><code>wrap_text</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = wrap_text $x
# or in a pipeline:
@list |> map wrap_text |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wrprng">
<h3><a class="doc-anchor" href="#doc-wrprng">#</a> <code>wrprng</code></h3>
<p><code>wrprng</code> — extended stdlib builtin. Alias for <code>wrap_range</code>.</p>
<pre><code class="lang-perl">my $result = wrprng $x
# or in a pipeline:
@list |> map wrprng |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wrpt">
<h3><a class="doc-anchor" href="#doc-wrpt">#</a> <code>wrpt</code></h3>
<p><code>wrpt</code> — extended stdlib builtin. Alias for <code>wrap_text</code>.</p>
<pre><code class="lang-perl">my $result = wrpt $x
# or in a pipeline:
@list |> map wrpt |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wsamp">
<h3><a class="doc-anchor" href="#doc-wsamp">#</a> <code>wsamp</code></h3>
<p><code>wsamp</code> — extended stdlib builtin. Alias for <code>weighted_sample</code>.</p>
<pre><code class="lang-perl">my $result = wsamp $x
# or in a pipeline:
@list |> map wsamp |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-wwrap">
<h3><a class="doc-anchor" href="#doc-wwrap">#</a> <code>wwrap</code></h3>
<p><code>wwrap</code> — extended stdlib builtin. Alias for <code>word_wrap_text</code>.</p>
<pre><code class="lang-perl">my $result = wwrap $x
# or in a pipeline:
@list |> map wwrap |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-xd">
<h3><a class="doc-anchor" href="#doc-xd">#</a> <code>xd</code></h3>
<p><code>xd</code> — serialization (stryke-only encoders) builtin. Alias for <code>xml_decode</code>.</p>
<pre><code class="lang-perl">my $result = xd $x
# or in a pipeline:
@list |> map xd |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-xe">
<h3><a class="doc-anchor" href="#doc-xe">#</a> <code>xe</code></h3>
<p><code>xe</code> — serialization (stryke-only encoders) builtin. Alias for <code>xml_encode</code>.</p>
<pre><code class="lang-perl">my $result = xe $x
# or in a pipeline:
@list |> map xe |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-xentropy">
<h3><a class="doc-anchor" href="#doc-xentropy">#</a> <code>xentropy</code></h3>
<p><code>xentropy</code> — math / numeric (uncategorized batch) builtin. Alias for <code>cross_entropy</code>.</p>
<pre><code class="lang-perl">my $result = xentropy $x
# or in a pipeline:
@list |> map xentropy |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-xirr">
<h3><a class="doc-anchor" href="#doc-xirr">#</a> <code>xirr</code></h3>
<p><code>xirr(\@cashflows, \@dates)</code> — computes IRR for irregularly-spaced cash flows. Dates can be epoch timestamps or date strings. More accurate than <code>irr</code> for real-world investments.</p>
<pre><code class="lang-perl">my @cf = (-1000, 500, 600)
my @dates = ('2020-01-01', '2020-07-01', '2021-01-01')
p xirr(\@cf, \@dates)
</code></pre>
</article>
<article class="doc-entry" id="doc-xor-bool">
<h3><a class="doc-anchor" href="#doc-xor-bool">#</a> <code>xor_bool</code></h3>
<p><code>xor_bool</code> — boolean combinators builtin.</p>
<pre><code class="lang-perl">my $result = xor_bool $x
# or in a pipeline:
@list |> map xor_bool |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-xor-strings">
<h3><a class="doc-anchor" href="#doc-xor-strings">#</a> <code>xor_strings</code></h3>
<p><code>xor_strings</code> — string helpers (batch 4) builtin.</p>
<pre><code class="lang-perl">my $result = xor_strings $x
# or in a pipeline:
@list |> map xor_strings |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-yards-to-m">
<h3><a class="doc-anchor" href="#doc-yards-to-m">#</a> <code>yards_to_m</code></h3>
<p><code>yards_to_m</code> — unit conversions builtin.</p>
<pre><code class="lang-perl">my $result = yards_to_m $input
</code></pre>
</article>
<article class="doc-entry" id="doc-yd">
<h3><a class="doc-anchor" href="#doc-yd">#</a> <code>yd</code></h3>
<p><code>yd</code> — serialization (stryke-only encoders) builtin. Alias for <code>yaml_decode</code>.</p>
<pre><code class="lang-perl">my $result = yd $x
# or in a pipeline:
@list |> map yd |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-ye">
<h3><a class="doc-anchor" href="#doc-ye">#</a> <code>ye</code></h3>
<p><code>ye</code> — serialization (stryke-only encoders) builtin. Alias for <code>yaml_encode</code>.</p>
<pre><code class="lang-perl">my $result = ye $x
# or in a pipeline:
@list |> map ye |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-yellow">
<h3><a class="doc-anchor" href="#doc-yellow">#</a> <code>yellow</code></h3>
<p><code>yellow</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = yellow $x
# or in a pipeline:
@list |> map yellow |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-yellow-bold">
<h3><a class="doc-anchor" href="#doc-yellow-bold">#</a> <code>yellow_bold</code></h3>
<p><code>yellow_bold</code> — color / ansi builtin. Alias for <code>red</code>.</p>
<pre><code class="lang-perl">my $result = yellow_bold $x
# or in a pipeline:
@list |> map yellow_bold |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-yesterday">
<h3><a class="doc-anchor" href="#doc-yesterday">#</a> <code>yesterday</code></h3>
<p><code>yesterday</code> — date (batch 2) builtin.</p>
<pre><code class="lang-perl">my $result = yesterday $x
# or in a pipeline:
@list |> map yesterday |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-z-score">
<h3><a class="doc-anchor" href="#doc-z-score">#</a> <code>z_score</code></h3>
<p><code>z_score($value, $mean, $stddev)</code> — computes the z-score (standard score) of a value given the population mean and standard deviation. Returns how many standard deviations the value is from the mean. Useful for standardizing data and detecting outliers.</p>
<pre><code class="lang-perl">my $z = z_score(85, 75, 10)
p $z # 1 (one stddev above mean)
p z_score(50, 60, 5) # -2
</code></pre>
</article>
<article class="doc-entry" id="doc-z-scores">
<h3><a class="doc-anchor" href="#doc-z-scores">#</a> <code>z_scores</code></h3>
<p><code>z_scores(@data)</code> — computes z-scores for all values in a list, returning an arrayref of standardized values. Each z-score indicates how many standard deviations that value is from the mean of the dataset. Useful for comparing values across different scales.</p>
<pre><code class="lang-perl">my @grades = (70, 80, 90)
my $zs = z_scores(@grades)
p @$zs # (-1, 0, 1)
@data |> z_scores |> e p
</code></pre>
</article>
<article class="doc-entry" id="doc-zalgo">
<h3><a class="doc-anchor" href="#doc-zalgo">#</a> <code>zalgo</code></h3>
<p><code>zalgo</code> — string processing (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = zalgo $x
# or in a pipeline:
@list |> map zalgo |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zall">
<h3><a class="doc-anchor" href="#doc-zall">#</a> <code>zall</code></h3>
<p><code>zall</code> — go/general functional utilities builtin. Alias for <code>zip_all</code>.</p>
<pre><code class="lang-perl">my $result = zall $x
# or in a pipeline:
@list |> map zall |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zcross">
<h3><a class="doc-anchor" href="#doc-zcross">#</a> <code>zcross</code></h3>
<p><code>zcross</code> — matrix operations (uncategorized batch) builtin. Alias for <code>zero_crossings</code>.</p>
<pre><code class="lang-perl">my $result = zcross $x
# or in a pipeline:
@list |> map zcross |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zero">
<h3><a class="doc-anchor" href="#doc-zero">#</a> <code>zero</code></h3>
<p><code>zero</code> — trivial numeric / predicate builtins builtin.</p>
<pre><code class="lang-perl">my $result = zero $x
# or in a pipeline:
@list |> map zero |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zero-crossings">
<h3><a class="doc-anchor" href="#doc-zero-crossings">#</a> <code>zero_crossings</code></h3>
<p><code>zero_crossings</code> — matrix operations (uncategorized batch) builtin.</p>
<pre><code class="lang-perl">my $result = zero_crossings $x
# or in a pipeline:
@list |> map zero_crossings |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zeros">
<h3><a class="doc-anchor" href="#doc-zeros">#</a> <code>zeros</code></h3>
<p><code>zeros</code> — matrix / linear algebra builtin.</p>
<pre><code class="lang-perl">my $result = zeros $x
# or in a pipeline:
@list |> map zeros |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zeros-mat">
<h3><a class="doc-anchor" href="#doc-zeros-mat">#</a> <code>zeros_mat</code></h3>
<p><code>zeros_mat</code> — matrix / linear algebra builtin. Alias for <code>zeros_matrix</code>.</p>
<pre><code class="lang-perl">my $result = zeros_mat $x
# or in a pipeline:
@list |> map zeros_mat |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zeros-matrix">
<h3><a class="doc-anchor" href="#doc-zeros-matrix">#</a> <code>zeros_matrix</code></h3>
<p><code>zeros_matrix</code> — matrix / linear algebra builtin.</p>
<pre><code class="lang-perl">my $result = zeros_matrix $x
# or in a pipeline:
@list |> map zeros_matrix |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zfill">
<h3><a class="doc-anchor" href="#doc-zfill">#</a> <code>zfill</code></h3>
<p><code>zfill</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = zfill $x
# or in a pipeline:
@list |> map zfill |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zfill-num">
<h3><a class="doc-anchor" href="#doc-zfill-num">#</a> <code>zfill_num</code></h3>
<p><code>zfill_num</code> — extended stdlib builtin.</p>
<pre><code class="lang-perl">my $result = zfill_num $x
# or in a pipeline:
@list |> map zfill_num |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zip-all">
<h3><a class="doc-anchor" href="#doc-zip-all">#</a> <code>zip_all</code></h3>
<p><code>zip_all</code> — go/general functional utilities builtin.</p>
<pre><code class="lang-perl">my $result = zip_all $x
# or in a pipeline:
@list |> map zip_all |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zip-apply">
<h3><a class="doc-anchor" href="#doc-zip-apply">#</a> <code>zip_apply</code></h3>
<p><code>zip_apply</code> — functional combinators builtin.</p>
<pre><code class="lang-perl">my $result = zip_apply $x
# or in a pipeline:
@list |> map zip_apply |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zip-archive">
<h3><a class="doc-anchor" href="#doc-zip-archive">#</a> <code>zip_archive</code></h3>
<p><code>zip_archive</code> — crypto / encoding builtin. Alias for <code>zip_create</code>.</p>
<pre><code class="lang-perl">my $result = zip_archive $x
# or in a pipeline:
@list |> map zip_archive |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zip-with">
<h3><a class="doc-anchor" href="#doc-zip-with">#</a> <code>zip_with</code></h3>
<p><code>zip_with</code> — pipeline / string helpers builtin. Alias for <code>drop</code>.</p>
<pre><code class="lang-perl">my $result = zip_with $x
# or in a pipeline:
@list |> map zip_with |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zipl">
<h3><a class="doc-anchor" href="#doc-zipl">#</a> <code>zipl</code></h3>
<p><code>zipl</code> — python/ruby stdlib builtin. Alias for <code>zip_longest</code>.</p>
<pre><code class="lang-perl">my $result = zipl $x
# or in a pipeline:
@list |> map zipl |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zipmap">
<h3><a class="doc-anchor" href="#doc-zipmap">#</a> <code>zipmap</code></h3>
<p><code>zipmap</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = zipmap $x
# or in a pipeline:
@list |> map zipmap |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zrlc">
<h3><a class="doc-anchor" href="#doc-zrlc">#</a> <code>zrlc</code></h3>
<p><code>zrlc</code> — physics formulas builtin. Alias for <code>impedance_rlc</code>.</p>
<pre><code class="lang-perl">my $result = zrlc $x
# or in a pipeline:
@list |> map zrlc |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zscore">
<h3><a class="doc-anchor" href="#doc-zscore">#</a> <code>zscore</code></h3>
<p><code>zscore</code> — file stat / path builtin.</p>
<pre><code class="lang-perl">my $result = zscore $x
# or in a pipeline:
@list |> map zscore |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zscores">
<h3><a class="doc-anchor" href="#doc-zscores">#</a> <code>zscores</code></h3>
<p><code>zscores</code> — statistics (extended) builtin. Alias for <code>z_scores</code>.</p>
<pre><code class="lang-perl">my $result = zscores $x
# or in a pipeline:
@list |> map zscores |> p
</code></pre>
</article>
<article class="doc-entry" id="doc-zst">
<h3><a class="doc-anchor" href="#doc-zst">#</a> <code>zst</code></h3>
<p><code>zst</code> — crypto / encoding builtin. Alias for <code>zstd</code>.</p>
<pre><code class="lang-perl">my $result = zst $x
# or in a pipeline:
@list |> map zst |> p
</code></pre>
</article>
</section>
</main>
</div>
<script src="hud-theme.js"></script>
</body>
</html>