GitHub Try it

No matching guides.

Home

Categories

Language

Ecosystem

Community

Guides

There are currently 176 tutorials, how-tos, and in-depth feature guides for Turmeric.

Visit the Spices page for spice-specific guides.

For docs for the Trowel editor, go here.

Operators2026-10-22Arithmetic, comparison, logical and bitwise operators -- which types each takes, how integers wrap and divide, and the float-only forms
tur serve2026-10-22Serve a directory over HTTP with tur serve, the Turmeric spelling of python3 -m http.server
Unsafe Code2026-10-22The (unsafe ...) block, raw pointers and raw memory, bit reinterpretation, and when to reach for something safer
The Build Driver2026-10-16How the tur driver turns a command line into a binary -- command dispatch and the global-flag parsers, the compile entry points and the real pass schedule, how cc is chosen and invoked, tur run and project mode, every cache and what invalidates it, the build-directory ladder, and the driver's environment variables
CPS and the DK Continuation Machine2026-10-16How the compiled path lowers effects and delimited control -- the coloring analysis, the CT-IR, the emitter's DK-threading ABI, the DK heap-continuation machine, who frees what, and the tools for debugging it
Diagnostics Internals2026-10-16How the compiler reports errors and warnings -- the DiagCode enum and its four tables, the diag_emit family, spans through sweet-exp, macros and loaded files, the terminal/JSON/LSP/embed sinks, tur explain, the errors/ fixture harness, and a checklist for adding a code
Effect Rows (internals)2026-10-16How effect rows are represented, parsed, inferred and checked -- the EffectRow kinds, the EffectEnv registry, the elaborator's effect checks, the effect-row pass and its fixpoint, capabilities and Unsafe, --dump-effects, and where codegen reads the rows
Elaborator Internals2026-10-16How the elaborator turns reader Forms into the typed Expr IR -- the Elab state and scope model, the two-pass top-level driver and the synthesized main, call-site-local type inference, the Expr and Type data model, what the elaborator records for later passes, incremental sessions, macros, and the checklist for adding a form
Who Frees What in Emitted Code2026-10-16How the direct-style C the compiler emits releases memory -- the ownership model and move tracking, drop glue, the by-value recursive spine drops (scope exit, lend, own-discharge), scope-exit frees and the shapes they decline, closure environments, carrier and element boxes, the rc<T> surface, and the workflow for confirming and pinning a leak
C Emitter Architecture2026-10-16How the C emitter turns an elaborated program into one translation unit -- the emit_value/emit_stmt contract, EmitCtx, the phase order of emit_program, ABI specializations, the side tables call sites consult, inline C, function definitions, and how to add an emit arm

Advanced Control Flow

Advanced Types

  • Advanced Type System -- Design Rationale -- Why Turmeric chose the type system features it did, why dependent types remain deferred, and how refinement types went from deferred to shipped
  • Existential Types -- Existential types: pack/open, typeclass constraints, hiding concrete types behind opaque boundaries
  • GADTs Cookbook -- GADTs cookbook: practical patterns and recipes
  • GADTs -- A Practical Guide -- GADTs: refined constructors (defdata with : Result), type refinement, equality witnesses, union types, gradual typing
  • Opaque Types (defopaque) -- Named nominal newtypes over a representation type -- what they are, what they're for, and how to construct, unwrap, and combine them with substructural disciplines

CLI Tools

  • Autodoc Guide -- Writing ;;; docstrings and generating API docs with tools/gendocs.py
  • Compiler Flags -- Diagnostic and debug flags accepted by tur; list of removed -X feature flags
  • Experimental Feature Flags -- The --enable=<name> surface for genuinely in-flight compiler features, the two lifecycles, the TUR-W006x warnings, and the tur experiments command.
  • Application Image Dumps -- Warm-start a Turmeric program by saving and restoring a post-init continuation, Lisp/Smalltalk/pdumper style.
  • Offline Docs Guide -- How the guides and API reference reach you without a network -- the docs pack, Try Turmeric's in-app docs browser, and the tur doc / tur docs commands
  • Test Runner Contract -- Test framework API and contract
  • tur compile and tur link -- Splitting the monolithic tur build into a cacheable object compile plus a cheap link -- tur compile, tur link, --split-build, and how --runtime= decides the way the runtime gets linked
  • Tur New Guide -- Scaffold a new Turmeric spice (library or binary) with standard layout, build manifest, tests, and optional CI
  • Tur Run Guide -- Built-in Justfile-compatible task runner for building, testing, and managing Turmeric projects without installing just
  • tur serve -- Serve a directory over HTTP with tur serve, the Turmeric spelling of python3 -m http.server
  • tur-watch Guide -- Cross-platform filesystem watching with debounce and coalescing for CLI tools
  • Turmeric Version Manager (tvm) -- Install, switch between, and pin Turmeric compiler releases the same way nvm does for Node -- per-user, no root, no system package manager.

Compiler Internals

  • The Build Driver -- How the tur driver turns a command line into a binary -- command dispatch and the global-flag parsers, the compile entry points and the real pass schedule, how cc is chosen and invoked, tur run and project mode, every cache and what invalidates it, the build-directory ladder, and the driver's environment variables
  • Compiler Internals -- The map of the tur compiler -- the pipeline and pass schedule, the src/ layout, and one paragraph per subsystem with a link to its deep-dive guide; the entry point for contributors
  • CPS and the DK Continuation Machine -- How the compiled path lowers effects and delimited control -- the coloring analysis, the CT-IR, the emitter's DK-threading ABI, the DK heap-continuation machine, who frees what, and the tools for debugging it
  • Diagnostics Internals -- How the compiler reports errors and warnings -- the DiagCode enum and its four tables, the diag_emit family, spans through sweet-exp, macros and loaded files, the terminal/JSON/LSP/embed sinks, tur explain, the errors/ fixture harness, and a checklist for adding a code
  • Effect Rows (internals) -- How effect rows are represented, parsed, inferred and checked -- the EffectRow kinds, the EffectEnv registry, the elaborator's effect checks, the effect-row pass and its fixpoint, capabilities and Unsafe, --dump-effects, and where codegen reads the rows
  • Elaborator Internals -- How the elaborator turns reader Forms into the typed Expr IR -- the Elab state and scope model, the two-pass top-level driver and the synthesized main, call-site-local type inference, the Expr and Type data model, what the elaborator records for later passes, incremental sessions, macros, and the checklist for adding a form
  • Who Frees What in Emitted Code -- How the direct-style C the compiler emits releases memory -- the ownership model and move tracking, drop glue, the by-value recursive spine drops (scope exit, lend, own-discharge), scope-exit frees and the shapes they decline, closure environments, carrier and element boxes, the rc<T> surface, and the workflow for confirming and pinning a leak
  • C Emitter Architecture -- How the C emitter turns an elaborated program into one translation unit -- the emit_value/emit_stmt contract, EmitCtx, the phase order of emit_program, ABI specializations, the side tables call sites consult, inline C, function definitions, and how to add an emit arm
  • Garbage Collection -- How memory is managed in Turmeric -- reference counting, the Bacon-Rajan cycle collector, arenas, and what is (and isn't) GC-managed in the compiled and interpreted paths
  • Name Mangling Guide -- How Turmeric turns source names into valid C identifiers -- the injective scheme, the legacy fold, and when each applies.
  • Ownership Guide -- Which ownership strategy to reach for -- persistent-immutable, single-owner mutable, linear/affine handles, rc<T> for genuine sharing, and weak<T> to break the resulting cycles
  • Package Manager Internals -- How tur reads build.tur, resolves :spices and workspace siblings, writes and honours tur.lock, generates and consumes the :cmake-deps CMake project, and threads :build-opts into the C compile -- with the traps each stage leaves for spice authors
  • How #lang r7rs Is Implemented -- How a #lang r7rs file becomes a Turmeric program -- dialect selection, the Scheme-to-Turmeric lowering and its rename table, the value representation, libraries and the split build, call/cc and the dynamic environment, the conservative collector, SRFIs, and the harnesses that cover them
  • Refinement Solver Internals -- How the compiler proves a refinement predicate at compile time -- the obligation pipeline, the normalized verification condition, the staged in-house solver (no SMT dependency), memoization, caps, and how to debug an obligation
  • Regions (RM3) Internals -- How region brackets work on the compiled path -- arena generations, rewind vs retire, the static walk and the runtime escape note, the store-hook rule and every place it is applied, the CPS and call/cc interactions, and the tools that tell a rewind from a retire
  • The Runtime Preamble and Its Linkage -- Where the C runtime every compiled program needs comes from -- the emitted preamble, its feature gates and linkage postures, the runtime archives, the S2 split runtime and its generator, tur_tls.c -- which copy each build path links, and how to change any of it without silently losing the fast path
  • Separate Compilation and Module Loading -- How the compiler finds, loads and resolves modules, which builds split a program into one C translation unit per module, what goes into each module's .h and .c, who owns a generic specialization or an instance across TUs, and how to read the link errors when the split goes wrong
  • The turi Interpreter (internals) -- How the tree-walking interpreter works -- its entry points, the shared front end it runs, value and frame representations, the explicit-stack driver, native overrides and inline-C, the two effect runtimes, what memory it gives back and what it keeps, process-global hazards, and how to add a form or native
  • turi <-> tur Parity Guide -- Feature-by-feature parity matrix between the compiled Turmeric path (tur) and the tree-walking interpreter (turi), the documented carve-outs, and how to check whether a given feature is interpretable.
  • Type Erasure to int64_t -- Snapshot of where the tur compiler collapses higher-level types down to int64_t at the C boundary, and the three mechanisms it uses
  • Typeclass Dictionary Internals -- How the compiler resolves a typeclass method call to an instance (receiver- and return-directed), what the call records, how constrained generics reach the right instance (monomorphization, dict clones, captured dictionaries), superclasses, default methods, HKT instances on the by-value path, instances across modules, how definstance lowers to a C dictionary struct + singleton, the closure-handle convention, and the failure shapes with their diagnostics.
  • Value Representations -- Every representation a Turmeric value can travel in, the boundaries where the compiler must bridge between them, and the failure shapes -- cc errors, link errors, segfaults -- when a bridge is missing

Concurrency and Async

Contributor Notes

  • Diagnosing the Compiler -- How Turmeric contributors narrow a suspected compiler bug -- ruling out the environment, finding the failing stage, the dump flags, three-way back-end comparison, the float and leak checkers, the source fuzzers, and the test-harness traps that produce false failures
  • JIT Execution Engine Guide (tur jit) -- How the in-process MIR JIT is built -- what MIR is, how the engine is wired into this project, and what it does differently from the cc path (the fallback contract, the permanent constraints, and the inline-C rules that only bite under the JIT)
  • Release Process -- How Turmeric releases are cut -- the three cut-*-release commands, their shared nine-step flow, the ordering constraints that make a failed cut recoverable, and what the release workflow does once the tag is pushed.
  • Running the Tests -- Which harness runs what, how to narrow a run to the tests you care about, the fixture marker files, and how to reproduce a red CI job locally
  • Test Suite Portability & Performance Guide -- macOS / Bash 3.2 gotchas, background-terminal SIGTTOU guards, inline-C math wrapper shadowing, and stamp-cache patterns for the test harnesses

Data Structures and Libraries

  • ECS Guide -- Building games and simulations with tur-ecs and the tur-ecs-raylib companion -- components, queries, systems, the row-typed Query value, and the standard 2D rendering loop.
  • ECS Storage Guide -- Dense, Sparse, Tag -- How tur-ecs's three component-storage backends -- Dense, Sparse, Tag -- differ in layout, cost, and ergonomics; when to pick each; how StorageOps unifies them; and how the Sized* variants thread a capacity through the type.
  • ECS -- tur-ecs vs apecs vs aztecs -- A side-by-side walk through a small game in apecs (Haskell), aztecs (Haskell), and tur-ecs (Turmeric), tabulating what each system catches at compile time vs. runtime, what each gives up to get there, and where the trade-offs actually land.
  • Files and Processes -- Read and write files, walk directories, manage symlinks and permissions, read stdin line by line, run child processes, handle signals, speak TCP and work with calendar dates through the typed fs / io / process / net / time / os stdlib -- every failure is a (Result T IoError)
  • Frame Guide -- In-memory columnar dataframes with tur-frame -- building, querying, joining, and exporting via the Arrow C Data Interface
  • HAMT Guide -- Persistent hash maps with structural sharing (HAMT)
  • JSON Guide -- Compile-time #json(...) reader macro and runtime tur/json library for parsing and serializing JSON
  • Markdown Guide -- Parse CommonMark and GitHub Flavored Markdown into a document tree with tur/markdown, render it as HTML, walk its blocks and inlines, and what is implemented so far
  • Parsec Reference Guide -- Reference for the stdlib parser-combinator library tur/parsec -- core types, primitive parsers, sequencing, choice, repetition, optional values, mapping, runners, and common patterns
  • Regular Expressions Guide -- Pure-Turmeric POSIX ERE regex engine -- compile, match, find, and replace
  • Runtime Schema Validation -- Validate untyped boundary data (HTTP bodies, config, IPC) with composable schema values using stdlib/schema.tur, with accumulating, path-tagged errors.
  • tur-stats Guide -- Statistics spice for Turmeric -- descriptive stats, probability distributions, hypothesis tests, OLS regression, and resampling on dataframes

Editor and IDE

  • AI Assistant Integration Guide -- Using the Turmeric MCP server and LSP with Copilot CLI, Claude CLI, OpenCode, and VS Code Copilot
  • Dev Container -- Running Turmeric development in a devcontainer from VS Code or the CLI
  • Formatter Guide -- tur format CLI and web REPL Format button
  • Language Server (LSP) Guide -- Configuring editors to use the Turmeric language server for diagnostics
  • Notebook Guide -- Literate-programming .tur.md notebooks with tur-notebook -- TUI interface, HTML export, and scripted exec mode
  • Time-Travel Tracing Guide (tur trace) -- Recording an interpreted run and scrubbing it -- what the .turtrace format holds, what the step cap protects, and how tur dap replays a recording so a debugger can step backwards
  • Vim Guide -- Vim / Neovim syntax highlighting installation and configuration
  • VS Code Extension -- VS Code extension installation and configuration

Error Handling

Functional Patterns

  • Arrows and Signal Processing -- Bare-function arrow combinators and building DSP signal graphs with stdlib/arrow.tur and stdlib/signal/
  • Effects vs. Monads -- When to reach for an effect handler and when to reach for a monad value
  • Generators and Lazy Sequences Guide -- Zero-overhead generators with gen/yield, lazy Seq combinators, and the Range type
  • Semigroups, Monoids, and Lattices -- The algebraic combining vocabulary in stdlib/typeclass-lattice.tur -- Semigroup, Monoid, the join/meet lattice classes, the selection newtypes that carry them, mconcat, and the law predicates.
  • Lens Guide -- First-class functional lenses (view / set / over) via stdlib/lens.tur, which ships the profunctor-by-record encoding. The classic van Laarhoven form is also expressible by hand.
  • Zipper Guide -- Generic zippers with stdlib/zip.tur -- a typed clojure.zip over any tree (ZipLoc), the Plated typeclass, and an element cursor over any container (ZipCursor).

Getting Started

  • Introducing Saffron -- A first tour of Saffron, the dynamically typed dialect of Turmeric: Try Turmeric in the browser, printing, flow control, functions, ADTs, typeclasses, and algebraic effects -- every example in both s-expression and sweet-expression syntax.
  • Quickstart -- Prose introduction: expressions, functions, control flow, Option, Result, collections, closures, structs, and algebraic effects
  • R7RS Scheme -- #lang r7rs -- #lang r7rs runs R7RS-small Scheme on the Turmeric compiler and runtime, compiled or interpreted, and lets Scheme and Turmeric modules import each other. This guide covers getting started, what is there, how it differs from the standard, and the tooling.
  • Releases and Installation -- How to install Turmeric from a prebuilt release or Homebrew, what's in the tarball, and how a maintainer cuts a new release.
  • tur repl -- REPL Reference -- Reference guide for the tur repl interactive read-eval-print loop, covering startup, expression evaluation, meta-commands, and configuration
  • Interactive REPL Tutorial -- 22-step interactive tutorial to follow at tur repl or the web REPL
  • Saffron -- the dynamically typed dialect -- #lang saffron makes any the default type, so parameters and returns need no annotations. This guide covers what changes, what stays, the eight dynamic operations, the checked boundary with typed Turmeric, and the one feature Saffron gives up.
  • Syntax Guide -- How to read and write Turmeric -- s-expression and sweet-expression syntax

Integration / Godot

  • Godot Binding Guide -- Attaching .tur scripts to Godot 4 nodes -- install, the curated and generated ClassDB facades, typed godot-call variants, value marshalling, the editor plugin and debugger, AOT mode, and the known gaps
  • Wiring a ResourceFormatLoader for the Turmeric/Godot Binding -- Why and how the turmeric-godot GDExtension has to register its own ResourceFormatLoader so .tur files load through Godot's resource pipeline

Interoperability

  • C Integration Guide -- Foreign function interface (FFI) and C interop
  • libturi -- C Embedding API Reference -- C embedding API for evaluating Turmeric expressions and calling Turmeric functions from within a C program using libturi.a
  • Dynamic FFI -- Calling C libraries at runtime -- dlopen/dlsym, call-ptr, extern-c under the interpreter, and the JIT thunk engine
  • Returning Result / Option from Inline-C -- Build typed Result/Option values inside inline-C bodies with the preamble helpers (tur_ok_ptr, tur_err_int, tur_some_ptr, tur_none, ...) instead of hand-rolling the struct or returning a magic-sentinel :int
  • Sandboxing Guide -- Restricting Turmeric code inside a C host with turi_env_new_sandboxed, capability flags, the native classification table, and resource limits -- and the memory-safety gap that keeps it from being a boundary against hostile code
  • Unsafe Code -- The (unsafe ...) block, raw pointers and raw memory, bit reinterpretation, and when to reach for something safer

Language Basics

  • Binding Forms Guide -- def in a body, letrec, and named-let -- the three local binding idioms that complement let and defn
  • CLI Arguments Guide -- Passing arguments to scripts with *args* and parsing them with stdlib/args.tur
  • Currying Guide -- Haskell-style partial application and over-application of Turmeric functions
  • Data Literals Guide -- Compact literal syntax for maps, vecs, and sets using #map{...}, #set{...}, and [...]
  • Fat-Closure Annotation Guide (^fat) -- When and why to mark function-typed parameters and return positions ^fat, and what breaks without it
  • Function Arity Style Guide -- When to use positional parameters, defstruct options, and variadic rest parameters -- plus the rules governing each
  • Macros Guide -- defmacro as a compile-time function from syntax to syntax -- quasiquote and splicing, manual hygiene, procedural defmacro*, macro-time imports, and why an expansion is type checked exactly like hand-written code
  • Module System Guide -- Module system, namespacing, exports
  • Mutable Globals Guide -- def ^mut, what the compiler checks about a global write, and the concurrency story -- including what it deliberately does not cover
  • Numeric Tower Guide -- Exact Rational and hand-written Complex arithmetic, the #rat{...} / #cx{...} literals, and Num-typeclass operator overloading
  • Operators -- Arithmetic, comparison, logical and bitwise operators -- which types each takes, how integers wrap and divide, and the float-only forms
  • Range Reader Shorthand Plan -- Plan for #r{...} reader-level range shorthand (RR0-RR4) -- desugars to Range constructor calls at read time
  • Reader Forms Reference -- Complete reference for every syntactic form the Turmeric reader recognises -- comments, literals, collections, prefix macros, and reader extensions
  • Strings Guide -- The three string tiers -- borrowed cstr, borrowed str view, and owned refcounted String -- which to reach for, #s"..." literals, zero-copy StringSlice, the lifetime rules, and the dangling-pointer pitfalls
  • Structs -- Defining and using struct types with defstruct
  • Sum Types and Either -- Declaring binary and n-ary sum types with defdata, pattern matching with match, exhaustiveness behaviour and the ^non-exhaustive opt-out, the FFI layout, and the stdlib Either module.
  • Symbols Guide -- First-class runtime symbols (:Sym type) with compile-time interning and optional dynamic str->sym table
  • Typing Handles, Callbacks, and Results -- Avoiding :int Stand-Ins -- How to type opaque handles, callbacks, and option/result values properly in Turmeric. Concrete patterns and fix recipes drawn from the 2026-06-14 spice ecosystem audit.

Networking and Web

  • Deploying Turmeric Services to Cloudflare -- Three approaches for deploying Turmeric-written services to Cloudflare -- Containers (simplest, works today), Interpreter-in-WASM (portable edge execution), and AOT WASM via emit-c (fastest cold starts).
  • HTTPD Async Guide -- Run handlers as fibers on a reactor thread -- non-blocking I/O, await primitives, in-flight cap, and middleware interop
  • HTTP Server with stdlib/httpd -- Build HTTP/1.1 servers with stdlib/httpd -- handlers, routing, middleware, and keep-alive
  • HTTP Middleware Catalog (stdlib/httpd) -- Reference for the shipped httpd middleware -- logging, CORS, basic auth, JSON, cookies, multipart, body-size, rate-limit, static files, security headers, request ids, trusted proxies, ETags, timeouts -- plus the request-attribute side channel and the composition helpers.
  • HTTPS with stdlib/httpd + tur-tls -- How to terminate TLS on an httpd-new server using the tur-tls spice
  • Tourist Routing Composition -- Compose tur-tourist HTTP sub-apps with mount and prefix combinators for larger applications
  • Tourist Session Middleware -- Cookie-backed sessions for tur-tourist with swappable storage backends (memory, file)
  • Tourist Web Stack End-to-End -- Build a complete web application with tourist routing, httpd, TLS, sessions, and template rendering -- the full stack wired together
  • Web Stack Guide -- Building HTTP servers with tur-httpd, tur-template, and tur-tourist -- the composable web stack for Turmeric
  • WebSockets -- Build RFC 6455 WebSocket clients and servers in Turmeric with the tur-ws-client and tur-ws-server spices

Package Management

Performance

  • Memory Usage Guide -- What each language feature costs in heap memory, measured -- scalars, structs, sums, lists, Vec, MutableMap, Map, String, rc, closures, function-value calls, effects and regions -- what frees it, and strategies for using less
  • Monomorphization ABI Guide -- How Turmeric's end-to-end monomorphization ABI works, why the by-value path replaced the int64 carrier, how to read __spec_* symbols in error messages, and what the small residual ABI bridge does.
  • Performance Guide -- Writing fast Turmeric programs -- numerical computation, data structures, string processing, concurrency, memory, recursion, I/O, and benchmarking methodology

Reference

  • Bibliography -- Academic papers, theses, and technical references cited across Turmeric design documents and guides
  • Turmeric Style Guide -- Canonical idioms and formatting conventions for Turmeric code -- function arity, indentation, naming, and inline-C style

Refinement Types

Security

  • Security Guide -- What Turmeric promises to handle safely -- the trust boundary for each input, the promise made at it, and where the implementation does not yet keep that promise

Troubleshooting

  • Debugging Turmeric Programs -- Finding out why a program does not compile, panics, crashes or prints the wrong thing -- reading diagnostics, tur explain, the tur debug stepper, editor debugging over DAP, tur build --debug under lldb/gdb, sanitizers for inline C, and tur demangle

Tutorials

Type Safety

  • Borrow Checking and Lifetimes Guide -- How Turmeric's borrow checker and lifetime elision work, and how to fix the errors they report
  • Refinement Types -- #refine{ x : T | p } predicates the compiler tries to prove statically, emitting a runtime check only where the proof fails -- the predicate language, named refinements, diagnostics, and the documented limits
  • Stateful Refinements -- Refining predicates over mutable state -- the frozen region and the #reads w annotation that grants congruence, why a trusted annotation is sound here, and how the guarded crossings codegen
  • Substructural Types -- ^linear, ^affine, ^relevant type disciplines
  • Uniqueness Types -- ^unique: at-most-one-reference ownership

Type System

  • Higher-Kinded Types -- Higher-kinded types (functor, monad, applicative abstractions, performance/dispatch model)
  • Higher-Ranked Types -- Higher-ranked types: rank-2/3 polymorphic function parameters
  • Approaches to Polymorphism -- A tour of the polymorphism mechanisms Turmeric provides -- parametric, ad-hoc, structural, row, kind, rank, and substructural -- with guidance on which one to reach for
  • Type-Level Rows -- The #row{...} reader form and the kind-[*] row type -- writing rows, row-kinded (^&) parameters, the row algebra (concat/union/intersect/canon), erasure, and what rows deliberately cannot do
  • Sized Primitive Types -- Fixed-width numeric types (int8/i8 through uint64/u64, float32/f32) -- literal syntax, coercion rules, and casting
  • Sized Types -- Tracking data-structure sizes in the type system for memory layout, stack allocation, and type-safe array operations
  • Type Annotation Syntax -- Compound type annotation syntax: (-> a b), (vec T), forall, and more
  • Typeclass Guide -- Comprehensive guide to Turmeric's typeclass system -- defining typeclasses with defclass, implementing instances with definstance, constraints, associated types, functional dependencies, and default implementations.
  • Union and Intersection Types Guide -- Union (A | B) and intersection (A & B) types, any, gradual typing