v0.9.4

Patternia v0.9.4 Release Note

Release Date: August 2026
Version: 0.9.4

---

Overview

Patternia v0.9.4 is a guard-focused release. It introduces PTN_BIND
member-anchored named placeholders for structural guards, unifies the
placeholder syntax around _ and PTN_BIND, and adds operator sugar
(!p, (a || b), (a && b)) for the pattern combinators.

This release contains breaking changes; see
Breaking Changes and the
Migration Guide below.

---

Breaking Changes

Positional guard APIs removed

The positional guard spellings are removed in favor of _ and
PTN_BIND:

Removed	Replacement
__ (double-underscore)	_
_0	_
arg<N>	PTN_BIND names
PTN_LET(v, expr)	PTN_BIND + guard expression
PTN_WHERE((a, b), expr)	PTN_BIND + guard expression

_ now serves both as the single-value guard placeholder and as the
wildcard fallback.

PTN_BIND names must be members of the type

PTN_BIND(Type, names...) expands each name to
member_t<&Type::name>. Placeholder names that were aliases rather
than real members of Type no longer compile; use the member names
themselves. Misspellings are now caught at the PTN_BIND line.

---

New Features

PTN_BIND(Type, names...) — named guard placeholders

Declares member-anchored named placeholders for guards attached to
has<...>, supporting one to ten names:

struct Point { int x; int y; };
PTN_BIND(Point, x, y);

match(p) | on(
  $(has<&Point::x, &Point::y>)[x * x + y * y == 25] >> "on circle",
  _ >> "elsewhere"
);

Names follow members, not positions: each name resolves to the
position of its member in the has<...> member list at compile time,
so the order of member pointers in has<...> does not matter:

$(has<&Point::y, &Point::x>)[x == 3 && y == 4]  // x is still .x

Misuse is caught at compile time: a misspelled member name fails at
the PTN_BIND line, and a name whose member is not listed in
has<...> fails a static_assert.

Declarations are valid at namespace or block scope. Block-scope
declarations use static storage duration, so they can be referenced
inside PTN_ON's captureless caching lambda:

int classify(const Point &p) {
  PTN_BIND(Point, x, y);
  return match(p) | PTN_ON(
      $(has<&Point::x, &Point::y>)[x * x + y * y == 25] >> 1,
      _ >> 0);
}

Operator sugar for combinators

The pattern algebra now has operator forms:

match(status) | on(
  !val<200>                  >> "error",     // !p     == neg(p)
  (lit(301) || lit(302))     >> "redirect",  // (a||b) == any(a, b)
  (pred(is_json) && !lit(0)) >> "json",      // (a&&b) == all(a, b)
  _                          >> "ok"
);

The operators only accept pattern operands, so guard-level && / ||
inside [...] keep their existing meaning. Note that >> binds
tighter than || and &&, so combined patterns need parentheses in a
case; unary ! needs none.

---

Internal Improvements

• CI: commit-style PR validation, clang-format check, LLVM
  source-based coverage, and a fix letting docs-only PRs satisfy
  branch protection.
• Bench: compile-time translation units are generated into the build
  tree instead of the source tree.
• Docs: contributing guide now documents the CI-enforced PR rules.

---

Migration Guide

PTN_LET / PTN_WHERE

// v0.9.3
auto g1 = PTN_LET(v, v == 1);
auto g2 = PTN_WHERE((x, y), x < y);

// v0.9.4 — single bound value: use `_`
$[_ == 1] >> ...;

// v0.9.4 — multiple bound values: declare names once
PTN_BIND(Point, x, y);
$(has<&Point::x, &Point::y>)[x < y] >> ...;

arg<N> / _0 / __

// v0.9.3
$[_0 > 0] >> ...;
$(has<&Point::x, &Point::y>)[arg<0> < arg<1>] >> ...;

// v0.9.4
$[_ > 0] >> ...;
PTN_BIND(Point, x, y);
$(has<&Point::x, &Point::y>)[x < y] >> ...;

Alias-style PTN_BIND names

// main-between-releases only (never in a tagged release):
PTN_BIND(Point, point_x, point_y);   // alias names

// v0.9.4 — names must be members of Point:
PTN_BIND(Point, x, y);