Turmeric Standard Library
Auto-generated API reference. Run just docs to regenerate.
Core
cstr
byte primitives on raw :cstr values.
schan
session-typed channel wrappers over a linear opaque handle.
time
Time capability implementation using platform time functions.
tur/args
CLI argument parser with a builder-pattern API.
tur/arrow
arrow combinators over the (->) function arrow, in two surfaces.
tur/async_file
non-blocking file I/O integrated with the cooperative scheduler.
tur/async_pipe
non-blocking stdin/stdout pipe I/O for the cooperative scheduler.
tur/async_socket
non-blocking TCP socket I/O for the cooperative scheduler.
tur/atomic
atomic load/store/add/sub/swap/CAS on 64-bit integers.
tur/backtrack
backtracking monad (list monad) for non-deterministic search.
tur/bits
bitwise operations not expressible as arithmetic in Turmeric.
tur/capability
capability-passing typeclasses for controlled side-effect injection.
tur/chan
synchronous and async buffered channels for inter-fiber communication.
tur/comonad
Comonad typeclass -- the categorical dual of Monad.
tur/concurrent
stub concurrency types for linear resource tracking.
tur/condvar
POSIX condition variable (pthread_cond_t) wrapped as ptr<void>.
tur/contract
runtime contract macros (assert!, require!, ensure!, ...).
tur/csv
CSV parser and emitter following RFC 4180.
tur/digest
SHA-256 and MD5 checksum implementations.
tur/dynvar
dynamic variables and binding conveyance for cooperative tasks.
tur/effects
standard algebraic effects for IO, logging, and randomness.
tur/either
binary sum type Either[L R]: Left l or Right r.
tur/env
environment variable access (getenv, setenv, unsetenv).
tur/equal
type-equality witness (Equal GADT) for type-safe coercions.
tur/existential
helpers for native pack/open existential types.
tur/fd
Fd: an opaque newtype over a POSIX file descriptor.
tur/fiber
lightweight cooperative fibers backed by the FiberBlock runtime.
tur/fix
Fix type: the fixed-point of a functor, with cata and ana.
tur/float-range
FloatRange: continuous interval with inclusive or exclusive ends.
tur/free
Free monad over a functor f for building effect DSLs.
tur/fs
extended file-system operations (stat, readdir, fnmatch, walk).
tur/future
Future<T> and Promise<T> for asynchronous results.
tur/gadt-vec
length-indexed GVec GADT with phantom natural-number type parameter.
tur/gen
generator helpers and macros for consuming and composing generators.
tur/grid
typed Grid[A]: 2D row-major grid parameterized over element type A.
tur/hamt
persistent hash-array-mapped trie (HAMT) map.
tur/hash
canonical integer hashing across numeric widths.
tur/httpd
Lightweight HTTP/1.0 and HTTP/1.1 server.
tur/httpd-compress
gzip response compression middleware.
tur/image
application image dumps via serializable continuations.
tur/image_hooks
standard resource-reacquisition hooks for image dumps.
tur/io
FileSystem capability implementation using libc functions.
tur/json
JSON encode and decode with no external dependencies.
tur/kleisli
the Kleisli arrow over Option: `Kleisli A B = A -> Option B`.
tur/lens
first-class functional lenses (getter/setter optics).
tur/list
typed singly-linked List[A] with Cons cells.
tur/list-typed
a phantom-typed (List A) view over the int64 cons-list
tur/log
Logger capability implementation using stderr/stdout.
tur/logic
miniKanren-style logic programming (unification, goals, streams).
tur/macros
core control-flow and utility macros (cond, when, for, do-m, ...).
tur/map
typed Map[K V]: persistent hash map requiring Hash[K] and MapKey[K].
tur/math
thin wrappers around libm functions (sin, cos, sqrt, ...).
tur/mutex
POSIX mutex (pthread_mutex_t) wrapped as ptr<void>.
tur/mutmap
MutableMap[K V]: mutable open-addressed hash table.
tur/nat
type-level natural numbers via GADT for phantom length annotations.
tur/net
stub networking type (Socket) for linear resource tracking.
tur/option
typed Option[A]: parameterized optional value.
tur/pair
typed Pair[A B]: parameterized two-element tuple.
tur/panic
inspect panics recovered by catch-unwind.
tur/parsec
parser combinator library built on the backtracking monad.
tur/path
pure path-string manipulation (join, dirname, basename, extension).
tur/process
process management: pid, spawn, wait, exec, cwd, chdir.
tur/random
Random capability implementation using the platform RNG.
tur/range
Range: continuous interval with inclusive, exclusive, or unbounded ends.
tur/range-bound
Bound A GADT: typed range endpoints (R3).
tur/rc
reference-counted pointer (rc<T>) for shared ownership.
tur/re
POSIX extended regular expressions via regcomp/regexec.
tur/reactor
lightweight evented I/O reactor.
tur/ref
heap-allocated mutable reference cell with independent ownership.
tur/refined
refinement newtypes for total collection accessors.
tur/result
typed Result[A B]: ok value A or err value B.
tur/rwlock
POSIX read-write lock (pthread_rwlock_t) wrapped as ptr<void>.
tur/safe
bounds-checked operations returning Option or Result.
tur/scheduler
cooperative fiber scheduler managing a fiber run queue.
tur/scheduler_mt
multi-threaded work-stealing scheduler for parallel fibers.
tur/schema
runtime schema validation for untyped boundary data.
tur/select
multi-channel select: wait on multiple channel operations at once.
tur/serial
serializable continuations for persistent workflow state.
tur/session
standard session-type protocol patterns for typed channels.
tur/set
typed Set[A]: persistent set backed by the HAMT.
tur/sized
static sizes and size arithmetic for memory layout verification.
tur/sized-bits
SizedBitVec: packed bit vector with static size annotations.
tur/sized-buf
SizedBuf: flat contiguous memory layout for sized types.
tur/sized-handle-existential
tur/sized-matrix
SizedMatrix: row-major 2D matrix with static size annotations.
tur/slice
typed Slice[A]: bounds-checked borrowed view into A elements.
tur/stm
Software Transactional Memory: transactional read/write on TVars.
tur/str
UTF-8 string view (pointer + length).
tur/sym
first-class interned runtime symbols (:Sym).
tur/sym-dynamic
opt-in runtime symbol interning (str->sym, SYM5).
tur/sync
Once and Semaphore synchronization primitives.
tur/taskgroup
structured concurrency with scoped TaskGroup.
tur/term
terminal utilities: size, tty detection, raw mode, ANSI colors.
tur/test
lightweight unit test runner for Turmeric.
tur/thread
POSIX thread spawn, join, and detach wrappers.
tur/threadpool
WorkQueue<T> and ThreadPool for task-based parallelism.
tur/timer
Timer API backed by a min-heap timer wheel.
tur/tuple
typed N-ary tuples (Tuple2..Tuple8).
tur/typeclass
built-in typeclasses: Eq, Ord, Show, Num.
tur/typeclass-alternative
Alternative -- container with an empty value and a choice combinator.
tur/typeclass-applicative
Applicative -- container with a pure constructor and an ap combinator.
tur/typeclass-bifunctor
Bifunctor -- map over both sides of a binary type constructor.
tur/typeclass-clone
minimal Clone typeclass stub for definstance sites.
tur/typeclass-eq
minimal Eq typeclass stub for typed-collection definstances.
tur/typeclass-functor
Phase TS5: Minimal Functor class stub for typed-collection definstances.
tur/typeclass-hash
minimal Hash typeclass stub for typed-collection keys.
tur/typeclass-monad
Monad -- sequencing with flatMap/bind.
tur/typeclass-monaderror
MonadError -- a monad m carrying an error channel e.
tur/typeclass-show
the Show typeclass, its primitive instances, and the
tur/unique
uniqueness-type patterns (with-unique, consume, replace).
tur/vec
typed Vec[A]: parameterized growable array.
tur/vec-existential
Vec[A] as a size-hiding existential for heterogeneous collections.
tur/workflow
persistent workflow helpers built on tur/serial.
tur/zipper
typed Zipper[A]: 1D list zipper with typed focus and neighbors.
seq
tur/builders
stdlib/seq/builders.tur -- Standard sequence constructors (LZ1)
tur/combine
stdlib/seq/combine.tur -- Sequence combinators (LZ3)
tur/consume
stdlib/seq/consume.tur -- Terminal sequence consumers (LZ3)
tur/core
stdlib/seq/core.tur -- Core Seq type and adapters (LZ0)
tur/transform
stdlib/seq/transform.tur -- Lazy sequence transformations (LZ2)