Chapter 23 — The “Not Yet” List

This is the most important chapter for keeping you honest, and it’s the promise from the front of the book made good. Everything else in this book runs today. The things below are designed but not yet built — they appear in Ingle’s manifesto, its spec, or its examples as intentions, and writing them today will not work. They’re listed so you know where the edge is, not so you’ll use them.

Types and polymorphism

  • Generic bounds on methods and enums — bounds (<T: Ord>, including several at once like <K: Hash + Eq>) work on free functions and on generic structs now — that’s exactly what the standard Map<K, V> is built from — but not yet on a generic struct’s individual methods or on generic enums. (Dynamic dispatch and bounded generic structs both landed; see Chapter 7 and Chapter 10. The only interfaces that can’t be value types are non-object-safe ones, and that’s a permanent design rule, not a missing feature.)
  • Move-type keys for Map — shipped. A Map/Set key need only be Hash + Eq; a move-type struct key is deep-cloned on store, so there’s no Copy requirement and no Clone ceremony (OFI-042). Closed since this book’s first draft.
  • Monomorphization — generics are compiled once (erased) today. The specialised per-type-for-speed release path is planned; you won’t write code differently for it.

Ownership and memory

  • Inferred return lifetimes — so a borrowed parameter could be returned without move. Today, returning an owned value needs move.
  • Full generic-body ownership and reclamation — shipped (June 2026). A generic body is ownership-checked like concrete code — a type parameter is a move type by default, Copy opts out — and refcounted values passing through it are reclaimed by the caller (OFI-009, and the OFI-117 tail). Earlier drafts listed this as a conservative leak-until-exit; that gap is closed.

Concurrency

  • M:N scheduling as the default — the M:N green-thread scheduler is built but gated behind make mn (structured cancellation-on-failure rides with it) while it clears a wider soak; the cooperative single-thread runtime stays the default until then. Also not yet: select/timeouts (the non-blocking try_recv poll is here — it’s select-with-a-default; waiting on several channels at once, and timeouts, aren’t), and main↔child channel communication during a nursery (today it’s child-to-child; main reads results after the nursery).

Values and text

  • Top-level var and non-literal global initialisers — top-level let constants (with literal values) work; general mutable globals don’t.
  • Unicode-aware strings — shipped (June 2026). Strings are fully UTF-8; chars() yields one string per code point, and the cp_* family (cp_count, cp_at, cp_slice, cp_prefix, cp_insert, cp_delete) gives Unicode-correct editing. Closed by OFI-055.
  • u64 literals above 2⁶³−1 — shipped (June 2026). A full-range literal like 18446744073709551615 (or with a u64 suffix) now writes directly; the parser reads the magnitude unsigned, and a value with the sign bit set is u64-only. Closed by OFI-123.

Foreign functions and capabilities

  • FFI returning C-owned memory — Ingle passes scalars, all-scalar structs, strings (const char*), packed buffers ([u8]/mut [u8]), and opaque Ptr handles across to C, and a returned char* now comes back as a copied-in string (the mechanism std/http uses to return a response body). What’s left is the other returning shapes: a non-string malloc‘d buffer (needs a length channel) and an “Ingle adopts and frees the pointer” form for ownership-transfer APIs — plus arbitrary dynamic linking.
  • Capabilities — the designed model for bounding what code may do (gating the FFI, then filesystem and network) is in the manifesto, not the language yet.

Tooling and language

  • Separate compilation / incremental rebuilds and metaprogramming (comptime vs. macros — deliberately undecided) are on the roadmap.

If you stick to the sixteen chapters before this one, you will never write a line that doesn’t compile for a reason on this list. That’s the deal.

Fireside trivia. A language that keeps a careful, public list of what it can’t do yet is rarer than it should be — the temptation is always to describe the destination as if you’d arrived. Ingle keeps two such lists in its own repository: a manifesto of decisions and a dated log of every bug and design flaw found while building (the cheerfully-named “Opportunities For Improvement”). The window that couldn’t accept a click on its very first frame; the uninitialised field that corrupted a function call; the generic that freed memory twice — all written down, numbered, and mostly closed.