6e346ab | plum | pyrossh

git clone https://git.pyrossh.dev/plum

A statically typed, imperative programming language inspired by rust, python

6e346ab — Peter John 2026-10-25T16:50:16+05:30

chore: drop stale Option/Result references from comments and tests

Files changed (12) hide show

plum-checker/src/lib.rs +16 -16
plum-checker/src/monomorphize.rs +81 -81
plum-checker/tests/checker_tests.rs +60 -60
plum-checker/tests/monomorphize_tests.rs +8 -8
plum-core/src/ast.rs +6 -6
plum-core/src/parser.rs +2 -2
plum-examples/error_propagation.plum +1 -1
plum-std/Array.plum +1 -1
plum-std/Try.plum +1 -1
plum-tooling/tree-sitter-plum/grammar.js +9 -10
plum-wasm-codegen/src/lib.rs +22 -22
plum-wasm-codegen/tests/codegen_tests.rs +6 -6

plum-checker/src/lib.rs CHANGED Viewed

@@ -333,7 +333,7 @@ pub fn lookup(env: &TypeEnv, name: &str) -> Result<PlumType, String> {
 pub type MethodEnv = BTreeMap<(String, String), PlumType>;
 /// Info about one `enum` variant: which enum it belongs to, its 0-based runtime tag
 /// (numbering is shared across all of that enum's variants), and its payload field
-/// types (empty for a payload-free variant like `Red` or `None`).
+/// types (empty for a payload-free variant like `Red` or `End`).
 #[derive(Debug, Clone, PartialEq)]
 pub struct EnumVariantInfo {
     pub enum_name: String,
@@ -341,7 +341,7 @@ pub struct EnumVariantInfo {
     pub field_types: Vec<PlumType>,
     /// Field names for a NAMED-payload variant (`Circle(radius: Int)`), aligned
     /// index-for-index with `field_types` — empty for the positional/generic-payload
-    /// form (`Some[T]`). See `ast::EnumVariant::field_names`.
+    /// form (`Next(T)`). See `ast::EnumVariant::field_names`.
     pub field_names: Vec<String>,
     pub values: Vec<ast::Expr>,
 }
@@ -543,9 +543,9 @@ pub fn buildGlobalTables(source: &ast::Source) -> (TypeEnv, MethodEnv, EnumVaria
 /// A `Type`'s name for comparison purposes only — deliberately ignores `.generics`
 /// entirely (on both sides), so a trait's bare return/param type (`cause() ->
-/// Option`, unable to name a concrete payload since a trait has no instance to
+/// Link`, unable to name a concrete payload since a trait has no instance to
 /// infer one from) is treated as compatible with ANY instantiation an implementer
-/// declares (`cause(self) -> Option[JsonParseError]`) — a real but deliberately
+/// declares (`cause(self) -> Link[JsonParseError]`) — a real but deliberately
 /// coarse check (arity + base type names), not full structural/generic equality.
 fn paramTypeCompareName(pt: &ast::ParamType) -> Option<&str> {
     match pt {
@@ -571,7 +571,7 @@ fn paramTypeCompareName(pt: &ast::ParamType) -> Option<&str> {
 /// a generic class's own methods (and a real trait's own declared signatures,
 /// which are never specialized at all) read naturally here, before mangling
 /// folds a method's concrete return/param types into new, unrelated-looking
-/// names (`Option[JsonParseError]` -> `Option$JsonParseError`).
+/// names (`Link[JsonParseError]` -> `Link$JsonParseError`).
 fn checkTraitConformance(source: &ast::Source) -> Vec<CheckError> {
     let mut errors = Vec::new();
     let traits: BTreeMap<&str, &ast::Trait> = source
@@ -668,7 +668,7 @@ pub fn checkSource(source: &ast::Source) -> CheckResult<()> {
     // A discriminant enum (`enum Foo(n: Int) = ...`) requires every variant to supply
     // exactly one value per declared param, unified against that param's type. An
     // ordinary (param-less) enum must NOT have variants with values — most likely
-    // caused by writing `Some(5)` where the generic-payload form `Some[Int]` was meant.
+    // caused by writing `Next(5)` in an enum that declares no discriminant params.
     for item in &source.items {
         if let ast::Item::Enum(e) = item {
             for v in &e.variants {
@@ -1425,7 +1425,7 @@ fn inferClassCallRaw(
     }
     match ctx.enum_variants.get(&call.type_name) {
         // A NAMED-payload enum variant (`Circle(radius: Int)`, as opposed to the
-        // positional/generic-payload form `Some[T]`, which never sets `field_names`
+        // positional/generic-payload form `Next(T)`, which never sets `field_names`
         // and so falls through to the permissive "unmodeled" case below) — this is
         // ALSO how a record-shaped, single-variant enum (the `type X = ...`
         // replacement, e.g. `enum Cat = | Cat(name: Str)`) constructs, with no
@@ -1465,7 +1465,7 @@ fn inferClassCallRaw(
             }
             Ok(PlumType::TNamed(info.enum_name.clone()))
         }
-        // Positional/generic-payload variant (`Some[T]`, constructed via `Expr::FnCall`
+        // Positional/generic-payload variant (`Next(T)`, constructed via `Expr::FnCall`
         // elsewhere instead), a payload-free variant, or an unmodeled (e.g.
         // builtin/std) type: allow, codegen will catch a genuine mismatch.
         _ => Ok(PlumType::TNamed(call.type_name.clone())),
@@ -1487,7 +1487,7 @@ fn bareVariantWrapType(type_name: &str, ctx: &CheckCtx) -> PlumType {
 }
 /// Checks a single case pattern against the type of the subject it matches, binding any
-/// new names it introduces into `env`. Constructor-payload sub-patterns (`Some(x)`) bind
+/// new names it introduces into `env`. Constructor-payload sub-patterns (`Next(x)`) bind
 /// against that variant's declared field types (see `EnumVariantInfo::field_types`).
 fn checkPattern(
     pat: &ast::CasePattern,
@@ -1700,8 +1700,8 @@ pub(crate) fn lookupFieldType(
                 // from here: `class_name` names a real, known NAMED-payload-capable
                 // enum that simply has no field by this name (a hard error), or it's
                 // an unresolved/unmodeled type name, OR a real enum whose variants
-                // are all positional/payload-free (`enum Option = | Some(Int) |
+                // are all positional/payload-free (`enum Link = | Next(Int) |
-                // None`, no `field_names` at all to check against — permissive,
+                // End`, no `field_names` at all to check against — permissive,
                 // codegen will catch a genuine mismatch, exactly as it always has).
                 // Distinguish by whether any variant belonging to this enum name
                 // declares named fields at all.
@@ -1726,7 +1726,7 @@ pub(crate) fn lookupFieldType(
 }
 /// A mangled variant name's own unmangled base (`"Ok$Int$Str"` -> `"Ok"`,
-/// `"None"` -> `"None"`) — `monomorphize::mangle` always joins the original
+/// `"End"` -> `"End"`) — `monomorphize::mangle` always joins the original
 /// variant name and its resolved type args with `$`, so the base is simply
 /// everything before the first `$`.
 fn variantBaseName(name: &str) -> &str {
@@ -1737,8 +1737,8 @@ fn variantBaseName(name: &str) -> &str {
 /// belonging to the same enum as `enum_name`, for the `?` operator (`Expr::Try`)
 /// — used identically by the checker (`inferExpr`) and codegen (`inferLocalType`
 /// callers), which is why this lives here rather than inline in either. Returns
-/// `None` if `enum_name` isn't (a monomorphized specialization of) `Result` or
+/// `None` if `enum_name` isn't (a monomorphized specialization of) `Try`
-/// `Option` — i.e. doesn't have both shapes of variant.
+/// — i.e. has no `Ok`/`Err` pair of variants.
 pub fn tryOperatorVariants<'a>(
     enum_name: &str,
     ctx: &'a CheckCtx,
@@ -1836,7 +1836,7 @@ pub fn inferExpr(expr: &ast::Expr, env: &TypeEnv, ctx: &CheckCtx) -> Result<Plum
         },
         ast::Expr::Paren(inner) => inferExpr(inner, env, ctx),
         // `expr?` — deliberately does NOT check that the enclosing function's
-        // return type actually accepts the `Err`/`None` value this can exit
+        // return type actually accepts the `Err` value this can exit
         // with early; that's left permissive here (codegen will catch a
         // genuine mismatch as a wasm type error), consistent with this
         // checker's existing "unmodeled/unvalidated, codegen catches it"
@@ -2245,7 +2245,7 @@ pub fn inferExpr(expr: &ast::Expr, env: &TypeEnv, ctx: &CheckCtx) -> Result<Plum
                         };
                         lookupFieldType(class_name, field_name, ctx)
                     }
-                    // An unresolved generic method return (e.g. `Result[T, E].unwrap()`'s
+                    // An unresolved generic method return (e.g. `Try[T, E].unwrap()`'s
                     // bare `T`, which this checker's `PlumType` erases entirely — see
                     // `types.rs`'s `TNamed` having no type-argument slot) reaches here as
                     // a plain `TVar`, not a real "wrong type". Field access on it is

plum-checker/src/monomorphize.rs CHANGED Viewed

@@ -49,7 +49,7 @@ pub fn fnGenericParams(f: &ast::Fn) -> Vec<String> {
 }
 /// The generic parameter names an `Enum` introduces — its OWN declared
-/// generics (`enum Option[T] = ...`) if it declares any, else (for an
+/// generics (`enum Link[T] = ...`) if it declares any, else (for an
 /// enum that doesn't) every distinct
 /// single-uppercase-letter variant field type name, in first-appearance
 /// order — the older, purely-implicit inference this replaces.
@@ -90,7 +90,7 @@ enum ExtraGenericSource {
 /// plain bare-letter param like `reduce`'s `acc: U` is also covered, via the
 /// same detection `fnGenericParams` already does for non-closure params). A
 /// closure's return type can ALSO nest the extra letter inside a container
-/// (`Option.andThen`'s `cb: fn(T) -> Option[U]`), not just be the bare
+/// (`Link.andThen`'s `cb: fn(T) -> Link[U]`), not just be the bare
 /// letter itself (`List.map`'s `cb: fn(T) -> U`) — `collectGenericParamNames`
 /// recurses to find either shape; `resolveMethodOwnGenerics`'s
 /// `ClosureReturn` handling knows how to bind a nested one back out.
@@ -382,11 +382,11 @@ fn substituteTypesInExpr(expr: &mut ast::Expr, subst: &Substitution) {
 /// generic parameters with its resolved concrete type's name.
 ///
 /// Variant names are ALSO mangled here, with the same suffix as the enum's own
-/// name (e.g. `Some` -> `Some$Int`) — even a payload-free variant like `None`.
+/// name (e.g. `Next` -> `Next$Int`) — even a payload-free variant like `End`.
 /// This is necessary because the runtime `EnumVariants` table (built by
 /// `buildGlobalTables`) is keyed by bare variant name globally: without this,
 /// two specializations of the same generic enum would both register a variant
-/// literally named `Some`, colliding in that flat table.
+/// literally named `Next`, colliding in that flat table.
 pub fn specializeEnum(e: &ast::Enum, subst: &Substitution, mangled_name: &str) -> ast::Enum {
     let params = enumGenericParams(e);
     let type_args: Vec<PlumType> = params
@@ -591,16 +591,16 @@ fn renameVarInArg(arg: &mut ast::Arg, old: &str, new: &str) {
 struct Monomorphizer<'a> {
     fns_generic: BTreeMap<String, &'a ast::Fn>,
-    /// Every method declared on a generic enum (e.g. `Result`'s `isOk`/`isErr`,
+    /// Every method declared on a generic enum (e.g. `Try`'s `isOk`/`isErr`,
     /// or a record-shaped `List`/`Map`'s own methods), keyed by the enum's own
     /// bare name.
     methods_generic_on_enum: BTreeMap<String, Vec<&'a ast::Fn>>,
-    /// Bare variant name (e.g. `"Some"`) -> the generic `Enum` it belongs to. Keyed
+    /// Bare variant name (e.g. `"Next"`) -> the generic `Enum` it belongs to. Keyed
-    /// by variant name because a construction site (`Some(5)`) parses as a `FnCall`
+    /// by variant name because a construction site (`Next(5)`) parses as a `FnCall`
     /// whose `name` is the VARIANT, not the enum's own name.
     enums_generic_by_variant: BTreeMap<String, &'a ast::Enum>,
     /// Mangled enum name -> {original variant name -> mangled variant name}, e.g.
-    /// `"Option$Int" -> {"Some": "Some$Int", "None": "None$Int"}`. Populated eagerly
+    /// `"Link$Int" -> {"Next": "Next$Int", "End": "End$Int"}`. Populated eagerly
     /// (in `resolveEnumInstantiation`, at the moment an instantiation's concrete
     /// type arguments become known) rather than waiting for the worklist to actually
     /// produce that specialization — so both a construction call site and a later
@@ -608,13 +608,13 @@ struct Monomorphizer<'a> {
     /// regardless of processing order.
     enum_variant_mangling: BTreeMap<String, BTreeMap<String, String>>,
     /// The enum's own bare name -> the generic `Enum` — used to detect a bare
-    /// generic-enum-typed function param (e.g. `o: Option`), distinct from
+    /// generic-enum-typed function param (e.g. `o: Link`), distinct from
     /// `enums_generic_by_variant` (keyed by VARIANT name, used for construction
-    /// sites like `Some(5)`).
+    /// sites like `Next(5)`).
     enums_generic_by_name: BTreeMap<String, &'a ast::Enum>,
     /// Free functions that are NOT generic by `fnGenericParams`'s lowercase-letter
     /// convention, but whose param type(s) bare-name a generic enum (e.g.
-    /// `unwrapOr(o: Option, ...)`) — such a function still needs its own
+    /// `unwrapOr(o: Link, ...)`) — such a function still needs its own
     /// per-call-site specialization, since its receiver generic enum is
     /// dropped from the monomorphized output and the bare name would otherwise
     /// resolve to nothing.
@@ -655,7 +655,7 @@ struct Monomorphizer<'a> {
     /// (the generic enum its declared return type names, the concrete type args
     /// it names them with) — for every function/method whose OWN declared return
     /// type is a fully-general instantiation of a known generic enum (e.g.
-    /// `-> Result[Int, Str]`). Populated once up front (in `monomorphizeSource`,
+    /// `-> Try[Int, Str]`). Populated once up front (in `monomorphizeSource`,
     /// alongside `enums_generic_by_name`) from the ORIGINAL, unmodified signatures
     /// — unlike everywhere else in this file, this doesn't need the specialization
     /// to have actually run yet, since the declared signature already says
@@ -808,10 +808,10 @@ impl<'a> Monomorphizer<'a> {
             env.insert(p.name.clone(), TypeScheme::mono(ty));
         }
         // The function's own return type, resolved for THIS specialization — used
-        // below to resolve a bare payload-free variant (`None`) that's the
+        // below to resolve a bare payload-free variant (`End`) that's the
         // BODY'S TAIL EXPRESSION (implicit return), the same way `Stmt::Return`
         // already does. A tail `Stmt::Expr` never goes through `Stmt::Return`'s
-        // own handling, so without this a trailing bare `None` is left
+        // own handling, so without this a trailing bare `End` is left
         // unmangled and later fails the real checker's return-type unification.
         let expected_ret = self
             .current_return_type
@@ -837,16 +837,16 @@ impl<'a> Monomorphizer<'a> {
                 self.rewriteBlock(block, &mut env)?;
                 // `inferConcrete` (not plain `infer`) — the tail's type feeds
                 // `maybeRewriteReturn` below, which needs the call's REAL
-                // specialized return type (e.g. `Option$Str`) when the tail is
+                // specialized return type (e.g. `Link$Str`) when the tail is
                 // a call to another function whose OWN declared return type
                 // instantiates a generic enum. Plain `infer` only consults
                 // `self.global_env`, built once from the ORIGINAL source
                 // before any mangling — so a tail like `return otherFn()`
-                // where `otherFn() -> Option[Str]` would infer the bare,
+                // where `otherFn() -> Link[Str]` would infer the bare,
-                // unmangled `Option` here, and `maybeRewriteReturn` would then
+                // unmangled `Link` here, and `maybeRewriteReturn` would then
                 // permanently freeze this function's OWN return annotation at
                 // that same bare, ungeneric name instead of the concrete
-                // `Option$Str` the body actually produces.
+                // `Link$Str` the body actually produces.
                 match block.stmts.last() {
                     Some(ast::Stmt::Expr(e, ..)) => Some(self.inferConcrete(e, &env)),
                     Some(ast::Stmt::Return(Some(e))) => Some(self.inferConcrete(e, &env)),
@@ -880,7 +880,7 @@ impl<'a> Monomorphizer<'a> {
     /// is `true` or `false`; the specialization path differs only in that its tail
     /// is inferred against a resolved substitution, so a generic-parameter-letter
     /// return resolves to the specialization's concrete bound type (which the
-    /// ordinary path cannot do). The unparseable-`None` fill-in is gated on
+    /// ordinary path cannot do). The unparseable-`End` fill-in is gated on
     /// `resolve_return` so an ordinary void function (`returns: None` meaning "no
     /// declared return", not "a generic return the grammar dropped") is never given
     /// a fabricated return type. Never fabricates a return from an un-inferrable
@@ -893,7 +893,7 @@ impl<'a> Monomorphizer<'a> {
             None => resolve_return,
             Some(rt) => {
                 // A generic enum named WITH concrete type args already
-                // (`-> List[Str]`, `-> Result[Int, Str]`) is already fully
+                // (`-> List[Str]`, `-> Try[Int, Str]`) is already fully
                 // resolved — only a genuinely BARE reference (`-> List`,
                 // `-> Box`, no `[...]` at all) is the "unresolved" shape this
                 // is meant to catch. Without the `rt.generics.is_empty()`
@@ -923,10 +923,10 @@ impl<'a> Monomorphizer<'a> {
     }
     /// Rewrites `pat` (bare-name/constructor pattern) in place: an uppercase variant
-    /// name gets mangled to its specialized form (`Some` -> `Some$Int`) if `mangling`
+    /// name gets mangled to its specialized form (`Next` -> `Next$Int`) if `mangling`
     /// says this position's subject is a specialized generic enum; a plain binding
     /// name is inserted into `case_env` at `ty`. Recurses into a constructor
-    /// pattern's own fields (`Some(Some(v))`), looking up *that* field's own
+    /// pattern's own fields (`Next(Next(v))`), looking up *that* field's own
     /// mangling table from `self.enum_variant_mangling` — a nested sub-pattern can
     /// be a specialization independent of its enclosing pattern's.
     fn manglePattern(
@@ -988,7 +988,7 @@ impl<'a> Monomorphizer<'a> {
         match stmt {
             ast::Stmt::Assign(a) => {
                 for (target, value) in a.targets.iter_mut().zip(a.values.iter_mut()) {
-                    // For a field target (`self.head = None`), resolve the
+                    // For a field target (`self.head = End`), resolve the
                     // value against the field's OWN declared type BEFORE the
                     // generic rewrite/inference below — same reasoning as
                     // `ClassCall`'s field values: a bare payload-free variant
@@ -1026,7 +1026,7 @@ impl<'a> Monomorphizer<'a> {
             ast::Stmt::Return(Some(e)) => {
                 // Same idea as the field-target case above, but against the
                 // enclosing function's own declared return type (`return
-                // None` inside a method returning `Option[Int]`).
+                // End` inside a method returning `Link[Int]`).
                 if let Some(rt) = self.current_return_type.clone() {
                     let resolved = self.resolveFieldType(&rt);
                     let expected = crate::plumTypeFromAst(&resolved);
@@ -1094,7 +1094,7 @@ impl<'a> Monomorphizer<'a> {
                     .collect();
                 // If a subject's concrete type is a specialized generic enum, its
                 // variant-name mangling table lets us rewrite that position's patterns
-                // (`Some`/`None` -> `Some$Int`/`None$Int`) to reference the correct
+                // (`Next`/`End` -> `Next$Int`/`End$Int`) to reference the correct
                 // specialization, so the checker/codegen's unmodified, bare-name-keyed
                 // `EnumVariants` lookup still resolves each pattern correctly.
                 let variant_manglings: Vec<Option<BTreeMap<String, String>>> = subject_types
@@ -1130,8 +1130,8 @@ impl<'a> Monomorphizer<'a> {
                     // A case body's own LAST statement, when it's a bare
                     // `Stmt::Expr`, is itself an implicit-return position
                     // whenever this whole `match` is the function's tail
-                    // expression (`first`/`last`'s `None =>` arm ending in a
+                    // expression (`first`/`last`'s `End =>` arm ending in a
-                    // bare `None`, for instance) — same reasoning as
+                    // bare `End`, for instance) — same reasoning as
                     // `rewriteFnBody`'s own tail-expression handling, just one
                     // level down through the match. Resolving against the
                     // function's OWN declared return type is a no-op unless
@@ -1180,7 +1180,7 @@ impl<'a> Monomorphizer<'a> {
             if let Some(idx) = variant.fields.iter().position(|t| t.name == *gp) {
                 let field_name = &variant.field_names[idx];
                 if let Some(fa) = call.fields.iter().find(|fa| &fa.name == field_name) {
-                    // A bare payload-free variant reference (`None`) carries
+                    // A bare payload-free variant reference (`End`) carries
                     // no type of its own to bind a generic param FROM — skip
                     // it here; it gets resolved AGAINST the binding (once
                     // known) below instead, same as every other field.
@@ -1192,9 +1192,9 @@ impl<'a> Monomorphizer<'a> {
             }
         }
         // No field is EVER directly typed as a bare generic param for a type
-        // like `List[T]` (its fields are `Option[Node[T]]`/`Int`, never a bare
+        // like `List[T]` (its fields are `Link[Node[T]]`/`Int`, never a bare
         // `T`) — and even where one exists, constructing with a payload-free
-        // value (`List(head: None, ...)`) gives no VALUE to infer a type from
+        // value (`List(head: End, ...)`) gives no VALUE to infer a type from
         // regardless. Fall back to an explicit `List[Int](...)` annotation at
         // the call site when field-value inference alone isn't enough.
         if bindings.len() != params.len() && call.generics.len() == params.len() {
@@ -1219,9 +1219,9 @@ impl<'a> Monomorphizer<'a> {
         // declared return type, exactly like `resolveEnumInstantiation` already
         // does for a generic-enum construction site that can't see every
         // parameter from its own arguments. This is what makes `fun
-        // makeList(values: ...T) -> List[T] = List(head: None, ...).add(values)`
+        // makeList(values: ...T) -> List[T] = List(head: End, ...).add(values)`
         // work: the bare `List(...)` construction gives no type witness at all
-        // (every field value is a payload-free `None`/`0`), but by the time
+        // (every field value is a payload-free `End`/`0`), but by the time
         // THIS function is specialized for a concrete `T`, `current_return_type`
         // has already been substituted to e.g. `List[Int]` by `specializeFn`.
         if bindings.len() != params.len() {
@@ -1249,10 +1249,10 @@ impl<'a> Monomorphizer<'a> {
         let mangled = self.ensureEnumSpecialized(e, &params, bindings);
         // Now that every generic param is bound, resolve any bare
-        // payload-free-variant field values (`None`) against THIS
+        // payload-free-variant field values (`End`) against THIS
         // specialization's own field types — codegen only ever sees the
         // mangled specialization (the generic template is dropped), so a
-        // still-bare `None` would be an unresolvable reference by the time it
+        // still-bare `End` would be an unresolvable reference by the time it
         // gets there.
         if let Some(info) = self.enum_variants.get(&mangled).cloned() {
             for fa in &mut call.fields {
@@ -1285,7 +1285,7 @@ impl<'a> Monomorphizer<'a> {
     /// `Attribute` arm — that generic walk seeds a closure's params as
     /// unconstrained `TVar`s (it has no way to know a method's declared
     /// closure-param types), and once a construction inside a closure body
-    /// (e.g. `andThen`'s `|n| Some(n / 2)`) gets mangled against a WRONG
+    /// (e.g. `andThen`'s `|n| Next(n / 2)`) gets mangled against a WRONG
     /// (`TVar`-derived) binding, nothing downstream can fix it —
     /// `resolveEnumInstantiation` only fires for a bare, still-unmangled
     /// variant name, so a premature wrong rewrite sticks permanently. Called
@@ -1437,7 +1437,7 @@ impl<'a> Monomorphizer<'a> {
                 }
                 ExtraGenericSource::ClosureReturn(i) => {
                     // The closure's body was already rewritten (any generic
-                    // construction inside it, e.g. `andThen`'s `Some(n / 2)`,
+                    // construction inside it, e.g. `andThen`'s `Next(n / 2)`,
                     // already mangled to its real specialization) by
                     // `rewriteMethodClosureArgs`, called before this — just
                     // re-seed the same closure-param env to infer its
@@ -1475,10 +1475,10 @@ impl<'a> Monomorphizer<'a> {
                     };
                     // A bare closure return (`cb: fn(T) -> U`, e.g. `List.map`)
                     // binds `letter` directly to the closure's whole inferred
-                    // type. A NESTED one (`cb: fn(T) -> Option[U]`, e.g.
+                    // type. A NESTED one (`cb: fn(T) -> Link[U]`, e.g.
-                    // `Option.andThen`) instead needs `bound` (the closure's
+                    // `Link.andThen`) instead needs `bound` (the closure's
-                    // ACTUAL concrete return, e.g. `Option$Int`) matched back
+                    // ACTUAL concrete return, e.g. `Link$Int`) matched back
-                    // against the DECLARED shape `Option[U]` to recover what
+                    // against the DECLARED shape `Link[U]` to recover what
                     // `U` itself was — `bindGenericArg` (shared with
                     // `resolveFnInstantiation`'s free-function argument
                     // binding) does exactly that structural extraction.
@@ -1511,7 +1511,7 @@ impl<'a> Monomorphizer<'a> {
         // generic-FREE-function machinery this reuses) are FLAT sets keyed by
         // this bare string alone, globally across the whole program — without
         // the receiver folded in, two unrelated receivers whose OWN method
-        // happens to mangle to the same suffix (e.g. `Option[Int].map` and
+        // happens to mangle to the same suffix (e.g. `Link[Int].map` and
         // `List[Int].map` both producing `"map$Str"`) would collide: the
         // second one popped would find the first's bare name already in
         // `specialized` and silently skip producing its own body.
@@ -1575,7 +1575,7 @@ impl<'a> Monomorphizer<'a> {
     }
     /// Without this, a method call chained directly onto a FRESH
-    /// enum construction in the same statement (`Some(4).filter(...)`, or
+    /// enum construction in the same statement (`Next(4).filter(...)`, or
     /// any `SomeVariant(...).method(...)` one-liner for a generic enum) could
     /// never resolve: the receiver's specialization is only ENQUEUED here,
     /// not fully produced until the worklist drains (well after the current
@@ -1675,9 +1675,9 @@ impl<'a> Monomorphizer<'a> {
     }
     /// If `expr` is a bare reference to a payload-free variant of a GENERIC
-    /// enum (`None`), and `expected` names a SPECIFIC specialization of that
+    /// enum (`End`), and `expected` names a SPECIFIC specialization of that
-    /// same enum (`Option$Node$Int`), rewrites `expr`'s name to that
+    /// same enum (`Link$Node$Int`), rewrites `expr`'s name to that
-    /// specialization's own mangled variant name (`None$Node$Int`) and
+    /// specialization's own mangled variant name (`End$Node$Int`) and
     /// ensures that specialization is registered — codegen only ever knows
     /// about specializations (the generic template enum is dropped entirely),
     /// so an un-rewritten bare reference would be unresolvable by the time it
@@ -1869,14 +1869,14 @@ impl<'a> Monomorphizer<'a> {
     /// `List[T]`), given `actual` — the ACTUAL concrete `PlumType` an argument
     /// declared as `declared` was inferred to have. The bare case (`declared`
     /// IS the letter, e.g. `a: T`) binds it directly to `actual`. The
-    /// container case (`declared` is `List[T]`/`Option[T]`/`Result[T, E]`,
+    /// container case (`declared` is `List[T]`/`Link[T]`/`Try[T, E]`,
     /// `actual` is that container's own mangled specialization like
     /// `List$Int`) looks up `actual`'s recorded `class_specialization_info`
     /// (the SAME table `resolveMethodOwnGenerics` already trusts for a
     /// method's own receiver) to recover the concrete type EACH of the
     /// container's own generic params was bound to, then recurses — so
     /// `List[T]` against `List$Int` binds `T -> Int`, and (one level deeper)
-    /// `List[Option[T]]` against `List$Option$Int` binds `T -> Int` too. A
+    /// `List[Link[T]]` against `List$Link$Int` binds `T -> Int` too. A
     /// mismatch (wrong container, or `actual` isn't even a named/specialized
     /// type) silently binds nothing for that param, same as before this
     /// existed — `resolveFnInstantiation`'s caller already rejects an
@@ -2006,8 +2006,8 @@ impl<'a> Monomorphizer<'a> {
     }
     /// The bare names of any generic class or enum referenced directly (not via a
-    /// lowercase-letter generic parameter) in `f`'s param types — e.g. `"Option"` for
+    /// lowercase-letter generic parameter) in `f`'s param types — e.g. `"Link"` for
-    /// `unwrapOr(o: Option, default: Int) -> Int`. See `fns_bare_generic`'s doc
+    /// `unwrapOr(o: Link, default: Int) -> Int`. See `fns_bare_generic`'s doc
     /// comment for why such a function needs its own specialization.
     fn fnBareGenericRefs(&self, f: &ast::Fn) -> Vec<String> {
         let mut names: Vec<String> = Vec::new();
@@ -2098,17 +2098,17 @@ impl<'a> Monomorphizer<'a> {
         Ok(())
     }
-    /// Resolves a construction of a generic enum's variant (e.g. `Some(5)` for
+    /// Resolves a construction of a generic enum's variant (e.g. `Next(5)` for
-    /// `enum Option = | Some(a) | None`), rewriting `call.name` from the bare
+    /// `enum Link = | Next(a) | End`), rewriting `call.name` from the bare
-    /// variant name (`Some`) to its mangled form (`Some$Int`) once the enum's own
+    /// variant name (`Next`) to its mangled form (`Next$Int`) once the enum's own
     /// concrete instantiation is known. Mangling is eager and deterministic — it
     /// doesn't wait for the worklist to actually produce the specialized `ast::Enum`
     /// (see `enum_variant_mangling`'s doc comment).
     ///
-    /// A variant that carries no generic fields (e.g. `None`) can't pin down the
+    /// A variant that carries no generic fields (e.g. `End`) can't pin down the
     /// enum's type parameters on its own, so such a construction site is left alone
-    /// here — some other construction site (e.g. `Some(5)`) is what drives the
+    /// here — some other construction site (e.g. `Next(5)`) is what drives the
-    /// specialization. (A bare `None` used as a *value*, not a call, is
+    /// specialization. (A bare `End` used as a *value*, not a call, is
     /// `ast::Expr::TypeName` and doesn't go through this function at all — see the
     /// plan's Global Constraints for that narrower, documented residual limitation.)
     fn resolveEnumInstantiation(
@@ -2167,11 +2167,11 @@ impl<'a> Monomorphizer<'a> {
             }
         }
         // This single construction site couldn't pin down every generic parameter
-        // by itself — e.g. `Ok(5)` only ever supplies `Result`'s `T`, never its `E`
+        // by itself — e.g. `Ok(5)` only ever supplies `Try`'s `T`, never its `E`
         // (no `Ok` call site can, since `Err`'s payload is a disjoint field). Fall
         // back to the enclosing function's declared return type, if it names this
         // same enum with an explicit, fully-general `[...]` instantiation (e.g.
-        // `-> Result[Int, Str]`) — that's the one other place a type this
+        // `-> Try[Int, Str]`) — that's the one other place a type this
         // construction site can't see on its own is written down on purpose.
         if bindings.len() != params.len() {
             if let Some(rt) = self.current_return_type.clone() {
@@ -2206,7 +2206,7 @@ impl<'a> Monomorphizer<'a> {
                             // `resolveClassInstantiation` — `gt` needs
                             // `resolveFieldType`'s recursive resolution
                             // before `plumTypeFromAst`, or a generic-with-args
-                            // type argument (e.g. `Result[Option[Int], Str]`)
+                            // type argument (e.g. `Try[Link[Int], Str]`)
                             // would have its own nested generics silently
                             // dropped.
                             let resolved = self.resolveFieldType(gt);
@@ -2322,7 +2322,7 @@ impl<'a> Monomorphizer<'a> {
         if !self.enum_variant_mangling.contains_key(&mangled) {
             // Insert a placeholder table BEFORE recursively resolving any variant's
             // own field types below — a self-referential generic enum (e.g. a
-            // linked-list `Node[T]`'s own `next: Option[Node[T]]` field) would
+            // linked-list `Node[T]`'s own `next: Link[Node[T]]` field) would
             // otherwise recurse right back into specializing itself here before
             // this specialization is even marked as in-progress, infinitely. The
             // recursive re-entry only ever needs this specialization's MANGLED
@@ -2360,14 +2360,14 @@ impl<'a> Monomorphizer<'a> {
             // Eagerly registers this specialization's ORDINARY methods'
             // signatures right now (see `registerEnumMethodSignatures`'s doc
             // comment) — a method called on this value in the SAME statement
-            // that constructs it (`Some(4).filter(...)`) needs
+            // that constructs it (`Next(4).filter(...)`) needs
             // `self.methods` to already know about it, well before the
             // worklist entry below is ever popped. MUST run only inside this
             // `if` (guarded by the `enum_variant_mangling` insert just
             // above, which marks this exact specialization as already being
             // set up) — a method whose own return type re-mentions this SAME
-            // specialization (`Option[T]`'s `filter` returning `Option[T]`)
+            // specialization (`Link[T]`'s `filter` returning `Link[T]`)
-            // recurses right back into `ensureEnumSpecialized("Option$Int",
+            // recurses right back into `ensureEnumSpecialized("Link$Int",
             // ...)`; running this unconditionally on every call (rather than
             // only the first) recurses infinitely and stack-overflows.
             self.registerEnumMethodSignatures(e, &mangled, &bindings);
@@ -2386,12 +2386,12 @@ impl<'a> Monomorphizer<'a> {
     /// Fully resolves a FIELD's declared type into something that will actually
     /// exist after monomorphization. `specializeEnum`'s own field substitution
     /// only replaces a bare generic-param NAME (`T` -> `Int`) — a field declared
-    /// `Option[Node[T]]` becomes `Option[Node[Int]]` this way, which is now
+    /// `Link[Node[T]]` becomes `Link[Node[Int]]` this way, which is now
-    /// fully CONCRETE but still names the generic TEMPLATES `Option`/`Node`
+    /// fully CONCRETE but still names the generic TEMPLATES `Link`/`Node`
     /// directly, both of which monomorphization deletes from the output (only
     /// their mangled specializations, e.g. `Node$Int`, survive). Recursively
     /// resolves any nested generic arguments first (so `Node[Int]` inside
-    /// `Option[Node[Int]]` becomes `Node$Int` before `Option[...]` itself is
+    /// `Link[Node[Int]]` becomes `Node$Int` before `Link[...]` itself is
     /// resolved), then — if the type names a known generic enum applied to
     /// arguments — mangles it to that specialization's real name and enqueues
     /// the specialization if it hasn't been already, via the same
@@ -2471,8 +2471,8 @@ impl<'a> Monomorphizer<'a> {
     /// originally declared, generics and all) to drive
     /// `resolveEnumInstantiation`'s fallback for construction sites that
     /// can't infer every generic param from their own arguments alone (e.g.
-    /// `Err("...")` needs `Result`'s OTHER param, `T`, from the function's
+    /// `Err("...")` needs `Try`'s OTHER param, `T`, from the function's
-    /// own `-> Result[Int, Str]` declaration) — flattening the return type
+    /// own `-> Try[Int, Str]` declaration) — flattening the return type
     /// up front would replace `rt.name` with an already-mangled name that
     /// fallback's own bare-template-name comparison can never match again.
     fn resolveFnParamTypes(&mut self, f: &mut ast::Fn) {
@@ -2482,11 +2482,11 @@ impl<'a> Monomorphizer<'a> {
                 ast::ParamType::Variadic(t) => *t = self.resolveFieldType(t),
                 // A closure-typed param's own param/return types can equally
                 // name a concrete generic instantiation after substitution
-                // (e.g. `andThen`'s `cb: fn(T) -> Option[U]` becomes `fn(Int)
+                // (e.g. `andThen`'s `cb: fn(T) -> Link[U]` becomes `fn(Int)
-                // -> Option[Int]` once `T`/`U` are bound) — leaving them
+                // -> Link[Int]` once `T`/`U` are bound) — leaving them
                 // unresolved meant this param's type, once turned into a
                 // `PlumType` via `plumTypeFromAst` for the body's own type
-                // env, silently flattened to a bare, unmangled `Option`
+                // env, silently flattened to a bare, unmangled `Link`
                 // (`plumTypeFromAst` drops every type's `.generics`
                 // regardless of nesting depth), so a call through the
                 // closure param (`cb(v)`) inferred the wrong, un-mangled
@@ -2515,12 +2515,12 @@ impl<'a> Monomorphizer<'a> {
     /// PRODUCED — it says nothing about code further downstream that CONSUMES an
     /// already-specialized generic-enum value returned from calling some other
     /// (already fully concrete, non-generic) function or method, e.g.
-    /// `match parseIt() { Ok(v) => ... }` where `fun parseIt() -> Result[Int, Str]`.
+    /// `match parseIt() { Ok(v) => ... }` where `fun parseIt() -> Try[Int, Str]`.
     /// `self.infer` can't help there either: it's built from `buildGlobalTables`,
     /// which (like every other `PlumType` site) drops a declared type's generic
-    /// args entirely (`plumTypeFromAst` maps `Result[Int, Str]` to the bare
+    /// args entirely (`plumTypeFromAst` maps `Try[Int, Str]` to the bare
-    /// `TNamed("Result")`) — so it has no way to know this call's result is the
+    /// `TNamed("Try")`) — so it has no way to know this call's result is the
-    /// SPECIALIZED `Result$Int$Str`, not the generic template.
+    /// SPECIALIZED `Try$Int$Str`, not the generic template.
     ///
     /// This resolves that one specific, common shape directly from the callee's own
     /// declaration (recorded in `fn_return_generic_enum` during classification) —
@@ -2580,7 +2580,7 @@ impl<'a> Monomorphizer<'a> {
                 }
                 // Runs next (before the generic per-field rewrite below): a
                 // bare payload-free variant field value (`Node(..., next:
-                // None)`) carries no type of its own to infer a generic
+                // End)`) carries no type of its own to infer a generic
                 // param from, and needs the enum's OWN (about-to-be-
                 // specialized) field type to resolve which specialization it
                 // actually means — `resolveClassInstantiation` handles that
@@ -2760,8 +2760,8 @@ impl<'a> Monomorphizer<'a> {
             ast::Expr::Compare(c) => {
                 self.rewriteExpr(&mut c.left, env)?;
                 self.rewriteExpr(&mut c.right, env)?;
-                // `current != None`: `current`'s side may already be a SPECIFIC
+                // `current != End`: `current`'s side may already be a SPECIFIC
-                // enum specialization (e.g. `Option$Node$Int`) while `None`
+                // enum specialization (e.g. `Link$Node$Int`) while `End`
                 // itself is still bare (it carries no type of its own) —
                 // resolve each side against the OTHER's type; a no-op unless
                 // that side is actually a bare generic-enum variant.
@@ -2799,9 +2799,9 @@ impl<'a> Monomorphizer<'a> {
             | ast::Expr::TypeName(_) => {}
             ast::Expr::Closure(cl) => {
                 // A closure literal's body can itself contain a generic
-                // construction site (`|v| Some(v)`) that needs rewriting to
+                // construction site (`|v| Next(v)`) that needs rewriting to
                 // its mangled variant/class name, same as anywhere else —
-                // without this, codegen later traps with "variant 'Some'
+                // without this, codegen later traps with "variant 'Next'
                 // missing from the GC type registry" the first time such a
                 // closure is actually compiled. The closure's OWN params
                 // aren't bound to any concrete type YET at this point in the
@@ -2876,7 +2876,7 @@ pub fn monomorphizeSource(source: &ast::Source) -> Result<ast::Source, String> {
     // `fn_return_generic_enum` loop below, which calls `resolveFieldType` and
     // can therefore trigger `registerEnumMethodSignatures` for a generic enum
     // as a SIDE EFFECT (e.g. resolving a nested `List[Str]` inside some other
-    // function's `-> Result[List[Str], Str]` return type).
+    // function's `-> Try[List[Str], Str]` return type).
     // `registerEnumMethodSignatures` looks up `methods_generic_on_enum` and,
     // finding it not yet populated, silently registers ZERO methods for that
     // specialization (`Some(methods) = ... else { return }`) — and because the
@@ -2924,7 +2924,7 @@ pub fn monomorphizeSource(source: &ast::Source) -> Result<ast::Source, String> {
                         // before `plumTypeFromAst`, same as every other site
                         // that turns a declared `ast::Type` generic argument
                         // into a `PlumType` — otherwise a nested generic type
-                        // argument (e.g. this method's own `Option[List[Json]]`
+                        // argument (e.g. this method's own `Link[List[Json]]`
                         // return type) has its `List[Json]` silently flattened
                         // to bare `List`, and every match on this method's
                         // return value ends up destructuring against the

plum-checker/tests/checker_tests.rs CHANGED Viewed

@@ -281,15 +281,15 @@ fn matchIntPatternAgainstStrSubjectIsError() {
 #[test]
 fn bareEnumTagUnifiesWithOwningEnumType() {
-    // Regression: a bare non-Bool tag like `None` used to type as `TNamed("None")`
+    // Regression: a bare non-Bool tag like `Nothing` used to type as `TNamed("Nothing")`
-    // (itself, not its enum), so comparing it against an `Option` value would wrongly
+    // (itself, not its enum), so comparing it against a `Maybe` value would wrongly
     // fail with a type mismatch.
     let src = "\
-enum Option =
+enum Maybe =
-  | Some(Int)
+  | Just(Int)
-  | None
+  | Nothing
-fun isNone(o: Option) -> Bool = o == None
+fun isNone(o: Maybe) -> Bool = o == Nothing
 ";
     let source = parse(src);
     let result = checkSource(&source);
@@ -299,12 +299,12 @@ fun isNone(o: Option) -> Bool = o == None
 #[test]
 fn variantConstructionChecksArgCountAndTypes() {
     let src = "\
-enum Option =
+enum Maybe =
-  | Some(Int)
+  | Just(Int)
-  | None
+  | Nothing
-fun makeSome(v: Int) -> Option =
+fun makeJust(v: Int) -> Maybe =
-  Some(v)
+  Just(v)
 ";
     let source = parse(src);
     let result = checkSource(&source);
@@ -314,12 +314,12 @@ fun makeSome(v: Int) -> Option =
 #[test]
 fn variantConstructionWrongArgTypeIsError() {
     let src = "\
-enum Option =
+enum Maybe =
-  | Some(Int)
+  | Just(Int)
-  | None
+  | Nothing
-fun bad() -> Option =
+fun bad() -> Maybe =
-  Some(\"x\")
+  Just(\"x\")
 ";
     let source = parse(src);
     let result = checkSource(&source);
@@ -380,9 +380,9 @@ enum Step(n: Int) =
 #[test]
 fn enumDiscriminantValueOnParamLessEnumIsError() {
     let src = "\
-enum Option =
+enum Maybe =
-  | Some(5)
+  | Just(5)
-  | None
+  | Nothing
 ";
     let source = parse(src);
     let result = checkSource(&source);
@@ -412,9 +412,9 @@ fn fieldAccessOnOrdinaryEnumReceiverIsUnaffectedByEnumParams() {
     // not the checker, is what would catch a genuinely bad field access here) —
     // exactly as it did before discriminant enums existed.
     let src = "\
-enum Option =
+enum Maybe =
-  | Some(Int)
+  | Just(Int)
-  | None
+  | Nothing
   fun bad(self) -> Int =
     self.n
@@ -570,15 +570,15 @@ fun useIt() -> Str =
 #[test]
 fn genericEnumSingleInstantiationTypeChecks() {
-    // A generic Option-shaped enum, constructed at one concrete type (`Some(5)`),
+    // A generic Maybe-shaped enum, constructed at one concrete type (`Just(5)`),
     // matched, must resolve end-to-end via checkSource.
     let src = "\
-enum Option[T] =
+enum Maybe[T] =
-  | Some(T)
+  | Just(T)
-  | None
+  | Nothing
 fun get() -> Int =
-  o = Some(5)
+  o = Just(5)
   match o
     Some(v) =>
       v
@@ -590,36 +590,36 @@ fun get() -> Int =
     assert!(result.is_ok(), "expected Ok, got {:?}", result.err());
     // Directly prove resolution happened: the monomorphized output must contain a
-    // concrete `Option$Int` enum whose `Some$Int` variant carries an `Int` field
+    // concrete `Maybe$Int` enum whose `Just$Int` variant carries an `Int` field
-    // (not the generic `a`), and must NOT retain the generic `Option` template.
+    // (not the generic `a`), and must NOT retain the generic `Maybe` template.
-    // The variant name is ALSO mangled (`Some` -> `Some$Int`), the same suffix as
+    // The variant name is ALSO mangled (`Just` -> `Just$Int`), the same suffix as
     // the enum's own name.
     let mono = plum_checker::monomorphize::monomorphizeSource(&source)
         .expect("monomorphize should succeed");
     let opt = mono.items.iter().find_map(|it| match it {
-        Item::Enum(e) if e.name == "Option$Int" => Some(e),
+        Item::Enum(e) if e.name == "Maybe$Int" => Some(e),
         _ => None,
     });
-    let opt = opt.expect("expected a specialized `Option$Int` enum in the output");
+    let opt = opt.expect("expected a specialized `Maybe$Int` enum in the output");
     let some = opt
         .variants
         .iter()
-        .find(|v| v.name == "Some$Int")
+        .find(|v| v.name == "Just$Int")
-        .expect("expected `Some$Int` (mangled) variant on `Option$Int`");
+        .expect("expected `Just$Int` (mangled) variant on `Maybe$Int`");
     assert_eq!(
         some.fields,
         vec![Type {
             name: "Int".to_string(),
             generics: vec![]
         }],
-        "Some's field should be concrete Int"
+        "Just's field should be concrete Int"
     );
     assert!(
         !mono
             .items
             .iter()
-            .any(|it| matches!(it, Item::Enum(e) if e.name == "Option")),
+            .any(|it| matches!(it, Item::Enum(e) if e.name == "Maybe")),
-        "the generic `Option` template must be dropped from the output"
+        "the generic `Maybe` template must be dropped from the output"
     );
 }
@@ -629,12 +629,12 @@ fn genericEnumMultipleInstantiationsCoexistAndTypeCheck() {
     // program must now type-check correctly for BOTH instantiations — this is the
     // behavior this task adds (previously this was a documented, rejected limitation).
     let src = "\
-enum Option[T] =
+enum Maybe[T] =
-  | Some(T)
+  | Just(T)
-  | None
+  | Nothing
 fun useInt() -> Int =
-  o = Some(5)
+  o = Just(5)
   match o
     Some(v) =>
       v
@@ -642,7 +642,7 @@ fun useInt() -> Int =
       0
 fun useStr() -> Str =
-  o = Some(\"x\")
+  o = Just(\"x\")
   match o
     Some(v) =>
       v
@@ -664,12 +664,12 @@ fun useStr() -> Str =
         })
     };
     assert!(
-        has_enum_with_variant("Option$Int", "Some$Int"),
+        has_enum_with_variant("Maybe$Int", "Just$Int"),
-        "expected Option$Int with Some$Int"
+        "expected Maybe$Int with Just$Int"
     );
     assert!(
-        has_enum_with_variant("Option$Str", "Some$Str"),
+        has_enum_with_variant("Maybe$Str", "Just$Str"),
-        "expected Option$Str with Some$Str"
+        "expected Maybe$Str with Just$Str"
     );
 }
@@ -724,11 +724,11 @@ fn ordinaryFunctionWithBareGenericEnumParamTypeChecks() {
     // The shape that broke the pre-existing codegen test: an otherwise-ordinary
     // function taking a bare generic-enum-typed parameter.
     let src = "\
-enum Option[T] =
+enum Maybe[T] =
-  | Some(T)
+  | Just(T)
-  | None
+  | Nothing
-fun unwrapOr(o: Option, default: Int) -> Int =
+fun unwrapOr(o: Maybe, default: Int) -> Int =
   match o
     Some(v) =>
       v
@@ -736,7 +736,7 @@ fun unwrapOr(o: Option, default: Int) -> Int =
       default
 fun use() -> Int =
-  unwrapOr(Some(5), 0)
+  unwrapOr(Just(5), 0)
 ";
     let source = parse(src);
     let result = checkSource(&source);
@@ -1134,18 +1134,18 @@ fn classImplementingTraitWithGenericReturnTypeMismatchIsPermitted() {
     // same generic type with a concrete arg is still a match (base type name
     // only; see `checkTraitConformance`'s doc comment).
     let src = "\
-enum Option[T] =
+enum Maybe[T] =
-  | Some(T)
+  | Just(T)
-  | None
+  | Nothing
 trait Err =
-  cause() -> Option
+  cause() -> Maybe
 enum MyErr(Err) =
   | MyErr(pos: Int)
-  fun cause(self) -> Option[MyErr] =
+  fun cause(self) -> Maybe[MyErr] =
-    None
+    Nothing
 ";
     let source = parse(src);
     assert!(
@@ -1403,9 +1403,9 @@ fn nested_union_in_payload() {
 #[test]
 fn tryOperatorVariantsOnlyOkErr() {
     let src = "\
-enum Opt =
+enum Maybe =
-  | Some(Int)
+  | Just(Int)
-  | None
+  | Nothing
 ";
     let source = parseClean(src);
     let (_, methods, variants, params) = plum_checker::buildGlobalTables(&source);

plum-checker/tests/monomorphize_tests.rs CHANGED Viewed

@@ -53,13 +53,13 @@ fn enumGenericParamsDetectsImplicitUppercaseLetterVariantFields() {
     let e = ast::Enum {
         line: 0,
         column: 0,
-        name: "Option".to_string(),
+        name: "Maybe".to_string(),
         generics: vec![],
         implements: vec![],
         params: vec![],
         variants: vec![
             ast::EnumVariant {
-                name: "Some".to_string(),
+                name: "Just".to_string(),
                 fields: vec![ast::Type {
                     name: "T".to_string(),
                     generics: vec![],
@@ -68,7 +68,7 @@ fn enumGenericParamsDetectsImplicitUppercaseLetterVariantFields() {
                 values: vec![],
             },
             ast::EnumVariant {
-                name: "None".to_string(),
+                name: "Nothing".to_string(),
                 fields: vec![],
                 field_names: vec![],
                 values: vec![],
@@ -154,13 +154,13 @@ fn specializeEnumSubstitutesGenericVariantFieldNames() {
     let e = ast::Enum {
         line: 0,
         column: 0,
-        name: "Option".to_string(),
+        name: "Maybe".to_string(),
         generics: vec![],
         implements: vec![],
         params: vec![],
         variants: vec![
             ast::EnumVariant {
-                name: "Some".to_string(),
+                name: "Just".to_string(),
                 fields: vec![ast::Type {
                     name: "T".to_string(),
                     generics: vec![],
@@ -169,7 +169,7 @@ fn specializeEnumSubstitutesGenericVariantFieldNames() {
                 values: vec![],
             },
             ast::EnumVariant {
-                name: "None".to_string(),
+                name: "Nothing".to_string(),
                 fields: vec![],
                 field_names: vec![],
                 values: vec![],
@@ -178,8 +178,8 @@ fn specializeEnumSubstitutesGenericVariantFieldNames() {
     };
     let mut bindings = std::collections::BTreeMap::new();
     bindings.insert("T".to_string(), PlumType::TInt);
-    let specialized = specializeEnum(&e, &Substitution(bindings), "Option$Int");
+    let specialized = specializeEnum(&e, &Substitution(bindings), "Maybe$Int");
-    assert_eq!(specialized.name, "Option$Int");
+    assert_eq!(specialized.name, "Maybe$Int");
     assert_eq!(
         specialized.variants[0].fields,
         vec![ast::Type {

plum-core/src/ast.rs CHANGED Viewed

@@ -102,7 +102,7 @@ pub struct Enum {
     /// rather than parsed).
     pub line: usize,
     pub column: usize,
-    /// The enum's OWN declared generic type parameters (`enum Option[T] =
+    /// The enum's OWN declared generic type parameters (`enum Link[T] =
     /// ...`). Empty for a non-generic enum.
     pub generics: Vec<GenericParam>,
     /// Trait names this enum claims to implement (`enum Cat(ToStr) = ...`).
@@ -126,7 +126,7 @@ pub struct EnumVariant {
     pub fields: Vec<Type>,
     /// Field names for a NAMED-payload variant (`Circle(radius: Int)`), aligned
     /// index-for-index with `fields` — empty for the older, still-supported
-    /// positional/generic-payload form (`Some[T]`), NOT one empty string per
+    /// positional/generic-payload form (`Next(T)`), NOT one empty string per
     /// field. Lets a construction site use named args (`Circle(radius: 5)`,
     /// parsed as an ordinary `ClassCall` — see `plum-checker`/`plum-wasm-codegen`'s
     /// `ClassCall` handling) instead of only positional ones (`Circle(5)`, still
@@ -361,11 +361,11 @@ pub enum Expr {
     ClassCall(ClassCall),
     /// `expr.field` or `expr.method(…)`
     Attribute(Box<AttributeExpr>),
-    /// `expr?` — unwraps a `Result`'s `Ok`/an `Option`'s `Some`, or returns the
+    /// `expr?` — unwraps a `Try`'s `Ok`, or returns the
-    /// `Err`/`None` value from the enclosing function as-is otherwise.
+    /// `Err` value from the enclosing function as-is otherwise.
     Try(Box<Expr>),
-    /// `left ?: right` — if `left` is `Ok(v)`/`Some(v)`, the value is `v`; if
+    /// `left ?? right` — if `left` is `Ok(v)`, the value is `v`; if
-    /// it's `Err(_)`/`None`, the value is `right`. Unlike `Try`, a plain
+    /// it's `Err(_)`, the value is `right`. Unlike `Try`, a plain
     /// expression with no early return.
     Elvis(Box<ElvisExpr>),
     /// `{expr}` — grouped/parenthesized expression

plum-core/src/parser.rs CHANGED Viewed

@@ -1089,7 +1089,7 @@ impl<'a> AstParser<'a> {
     }
     fn parseElvis(&self, node: Node) -> Expr {
-        // elvis_expression: expression "?:" expression
+        // elvis_expression: expression "??" expression
         let named: Vec<Node> = self.namedChildren(node);
         let left = named
             .first()
@@ -1161,7 +1161,7 @@ impl<'a> AstParser<'a> {
     /// safe_attribute: primary_expression "?." fn_identifier fn_argument_list?
     ///
     /// Desugars entirely here into `object.map(|v| v.member(...))` — reusing
-    /// Option/Result's existing generic `.map` method for the actual
+    /// Try's existing generic `.map` method for the actual
     /// unwrap/transform/rewrap, so nothing past the parser (checker,
     /// monomorphizer, codegen, formatters) needs to know `?.` exists at all.
     /// The synthesized param name can't collide with a real variable in scope:

plum-examples/error_propagation.plum CHANGED Viewed

@@ -7,7 +7,7 @@ import std/List
 # `Try[T, E]` is either `Ok(T)` or `Err(E)`. `E` is normally a tag union such
 # as `[NegativeNum, BadNumStr]`: a set of bare tags (optionally carrying a
 # payload, e.g. `InvalidJson(Str)`) that needs no declaration. There is no
-# `Option`: a missing value is just an error tag like `[OutOfBounds]`.
+# A missing value is just an error tag like `[OutOfBounds]`.
 #
 # `expr?` unwraps an `Ok`, or exits the enclosing function early with the
 # `Err` value. The error unions of different calls merge automatically into

plum-std/Array.plum CHANGED Viewed

@@ -29,7 +29,7 @@ import std/Number
 # fixed-length allocation once made), so it allocates a new, one-longer array
 # and copies, same amortized-growth idea as `Buffer`'s own `write`.
 #
-# New elements start out `None`-shaped — really a null `anyref` under the
+# New elements start out null-shaped — really a null `anyref` under the
 # hood — so `get` on an index that was never `set` traps rather than
 # returning some default `T` value (there is no way to conjure a default `T`
 # generically).

plum-std/Try.plum CHANGED Viewed

@@ -10,7 +10,7 @@ import std/Map
 # carrying an `E`). `E` is normally a structural tag union such as
 # `[NotFound, BadNum(Str)]`; `?` merges the error unions of different calls
 # into the enclosing function's declared union. A missing value is just an
-# error tag (`[OutOfBounds]`, `[KeyNotFound]`, ...), so there is no Option.
+# error tag (`[OutOfBounds]`, `[KeyNotFound]`, ...), with no separate optional type.
 enum Try[T, E] =
   | Ok(T)
   | Err(E)

plum-tooling/tree-sitter-plum/grammar.js CHANGED Viewed

@@ -202,7 +202,7 @@ module.exports = grammar({
         field(
           "parameters",
           optional(choice(
-            // Positional payload, e.g. `Some(Int)`/`Some(T)` — brackets are
+            // Positional payload, e.g. `Next(Int)`/`Next(T)` — brackets are
             // reserved for generics (a type/trait/enum's OWN declared
             // params, and instantiating one, e.g. `List[Int]`); a variant's
             // payload always uses parens, same as a class field's type.
@@ -533,9 +533,8 @@ module.exports = grammar({
         ),
       ),
-    // Rust-style error-propagation postfix: `expr?` — unwraps a `Result`'s `Ok`
+    // Rust-style error-propagation postfix: `expr?` — unwraps a `Try`'s `Ok`, or exits the enclosing function early with the
-    // or an `Option`'s `Some`, or exits the enclosing function early with the
-    // `Err`/`None` value as-is otherwise. Same postfix shape/precedence as
+    // `Err` value as-is otherwise. Same postfix shape/precedence as
     // `attribute` (`.`) just above.
     try_expression: ($) =>
       choice(
@@ -553,12 +552,12 @@ module.exports = grammar({
       ),
     // Groovy/Kotlin-style safe navigation: `obj?.member` / `obj?.method(args)`
-    // on a `Result`/`Option` value — same shape as `attribute` just above, but
+    // on a `Try` value — same shape as `attribute` just above, but
     // with a `?.` token in place of `.`. `?.` is its own literal token, so the
     // lexer's usual longest-match rule already picks it over a bare `?` (the
     // `try_expression` token) with no extra grammar conflict needed, the same
-    // way `elvis_expression`'s `?:` needed none. Desugars entirely in
+    // way `elvis_expression`'s `??` needed none. Desugars entirely in
-    // `parser.rs` (into `.map(|v| v.member(...))`, reusing Option/Result's
+    // `parser.rs` (into `.map(|v| v.member(...))`, reusing Try's
     // existing generic `.map`) — nothing past the parser ever sees this node.
     safe_attribute: ($) =>
       prec(
@@ -641,9 +640,9 @@ module.exports = grammar({
         seq($.expression, "?", $.expression, ":", $.expression),
       ),
-    // Elvis / null-coalescing: `opt ?: default` — if `left` is `Ok(v)`/`Some(v)`,
+    // Elvis / null-coalescing: `opt ?? default` — if `left` is `Ok(v)`,
-    // the value is `v`; if it's `Err(_)`/`None`, the value is `right`. A single
+    // the value is `v`; if it's `Err(_)`, the value is `right`. A single
-    // atomic `"?:"` token (maximal munch out-munches the bare `"?"` ternary/
+    // atomic `"??"` token (maximal munch out-munches the bare `"?"` ternary/
     // try-operator tokens at the same position, so — unlike `try_expression`,
     // which genuinely shares ternary's leading `?` and needs the `conflicts`
     // entry above — this needs no special conflict handling).

plum-wasm-codegen/src/lib.rs CHANGED Viewed

@@ -383,7 +383,7 @@ pub struct CompileCtx<'a> {
     /// wasm-gc type-section indices for this program's enums/Str/closures —
     /// every value's real representation (see `docs/superpowers/plans/2026-07-25-wasm-gc-migration.md`).
     pub gc_types: GcTypeRegistry,
-    /// Payload-free variant name (True/False/None/...) -> the global index holding
+    /// Payload-free variant name (True/False/End/...) -> the global index holding
     /// its one pre-allocated instance (see this migration plan's Decision 2).
     pub singleton_globals: HashMap<String, u32>,
 }
@@ -404,7 +404,7 @@ struct LocalCtx<'a> {
     /// `Match` stmt identity (pointer address) -> scratch slot offset.
     match_scratch_index: HashMap<usize, u32>,
     /// First local index reserved for nested-constructor-pattern scratch temporaries
-    /// (`Some(Some(v))`'s inner `Some(v)`); the outermost pattern uses a
+    /// (`Next(Next(v))`'s inner `Next(v)`); the outermost pattern uses a
     /// `match_scratch` slot instead, so this only covers depth >= 1.
     nested_class_scratch_base: u32,
     /// `CasePattern::Class` identity (pointer address) -> scratch slot offset.
@@ -702,7 +702,7 @@ fn classOrVariantTypeIdx(r: &GcTypeRegistry, name: &str) -> u32 {
         .or_else(|| r.class_type_idx.get(name))
         // A scratch slot narrowed to a MULTI-variant enum's own wide supertype
         // (not any one variant) — the `?` operator's scratch local holds the
-        // subject at its natural (possibly multi-variant, e.g. `Result`/`Option`)
+        // subject at its natural (possibly multi-variant, e.g. `Try`)
         // type, never narrower, since it ref.casts to whichever of the two
         // variants applies only at the point of use, not up front.
         .or_else(|| r.enum_super_type_idx.get(name))
@@ -917,11 +917,11 @@ fn plumTypeToGcValtype(t: &PlumType, registry: &GcTypeRegistry) -> ValType {
                 nullable: true,
                 heap_type: HeapType::Concrete(*idx),
             }),
-            // A field typed as a generic enum (e.g. `Node.next: Option[Node]`)
+            // A field typed as a generic enum (e.g. `Node.next: Link[Node]`)
             // resolves here to the BARE generic name — `plumTypeFromAst`
             // has no representation for type arguments, so it can't know this means
-            // `Option$Int` once monomorphization specializes (and removes the
+            // `Link$Int` once monomorphization specializes (and removes the
-            // unspecialized) `Option` — same permissive `anyref` fallback as
+            // unspecialized) `Link` — same permissive `anyref` fallback as
             // `plumTypeToValtype` above, for the same "genuinely unmodeled" reason:
             // `struct.get`/`ref.test`/`ref.cast` all work against `anyref` operands
             // fine, so a field merely being STORED as `anyref` instead of the exact
@@ -943,7 +943,7 @@ fn plumTypeToGcValtype(t: &PlumType, registry: &GcTypeRegistry) -> ValType {
 /// ONE `rec` group via `module.addGcTypes` — a single group sidesteps every ordering
 /// question about mutual/self-references (a record-shaped enum's field naming
 /// another such enum's type, an enum variant field referencing its own enum,
-/// `Node.next: Option[Node]`, etc.), since within one `rec` group members may
+/// `Node.next: Link[Node]`, etc.), since within one `rec` group members may
 /// reference each other regardless of declaration order.
 fn buildGcTypeRegistry(
     module: &mut WasmModule,
@@ -1611,7 +1611,7 @@ fn compileSourceInner(
         }
     }
-    // Pre-allocate one instance of every payload-free variant (True/False/None/...)
+    // Pre-allocate one instance of every payload-free variant (True/False/End/...)
     // as a global, populated once by a `start` function rather than reconstructed on
     // every reference — see this migration plan's Decision 2. `struct.new` isn't
     // allowed inside a global's own const-expr initializer (confirmed empirically in
@@ -2087,7 +2087,7 @@ fn registerStringConcatHelper(module: &mut WasmModule, byte_array_type_idx: u32)
 /// Registers `__string_eq(a: ref Str, b: ref Str) -> i32` (1/0), a hand-written
 /// runtime helper backing `Str`'s `==`/`!=` operator. `Str` is a wasm-gc `ref` —
 /// the general `Compare` codegen's default for reference-typed operands is
-/// `ref.eq` (identity), correct for a payload-free singleton (`None`/`True`) or
+/// `ref.eq` (identity), correct for a payload-free singleton (`End`/`True`) or
 /// class-instance identity, but WRONG for `Str`: two independently-heap-allocated
 /// `array<i8>` values holding identical bytes (e.g. two `"a"` literals, or one
 /// literal and a runtime-built string) are different objects and would compare
@@ -3352,7 +3352,7 @@ struct Collector<'a> {
     /// One scratch-local type per subject (usually one, more for `match a, b, ...`).
     match_scratch: HashMap<usize, Vec<PlumType>>,
     /// `CasePattern::Class` identity -> its scratch local. Covers EVERY constructor
-    /// pattern, including top-level ones — under wasm-gc, matching `Some(v)` needs a
+    /// pattern, including top-level ones — under wasm-gc, matching `Next(v)` needs a
     /// `ref.cast` from the subject's static supertype down to the concrete variant
     /// type before any `struct.get` on it validates, and that narrowed value needs
     /// its OWN local (declared with the concrete variant's ref type) distinct from
@@ -3550,12 +3550,12 @@ impl<'a> Collector<'a> {
             }
             ast::Expr::Not(inner) => self.walkExpr(inner),
             // `expr?` needs a scratch local to hold `inner`'s value across the
-            // `ref.test` that decides Ok/Some vs Err/None (which consumes it)
+            // `ref.test` that decides Ok vs Err (which consumes it)
             // and the `ref.cast` that reads it again inside whichever branch —
             // reuses the same pointer-identity-keyed scratch-slot mechanism
             // constructor patterns already use (`nested_class_scratch`), keyed
             // by this `Expr::Try` node itself. Declared with `inner`'s own
-            // (possibly multi-variant, e.g. `Result`/`Option`) enum type —
+            // (possibly multi-variant, e.g. `Try`) enum type —
             // `classOrVariantTypeIdx` falls back to `enum_super_type_idx` for
             // exactly this case — since narrowing happens later via `ref.cast`
             // in each branch, not by declaring this local pre-narrowed.
@@ -4383,7 +4383,7 @@ fn exprHasResult(expr: &ast::Expr, ctx: &LocalCtx) -> bool {
 /// patterns" fallback in `compile_match_arms` is provably unreachable code, not a real
 /// gap. `compileMatch` uses this to append a synthetic trap-and-never-fall-through
 /// wildcard arm (rather than let the arms recursion hit its non-exhaustive-match error)
-/// so previously-working exhaustive enum matches (e.g. `Some`/`None`, `True`/`False`)
+/// so previously-working exhaustive enum matches (e.g. `Next`/`End`, `True`/`False`)
 /// keep compiling even without a trailing wildcard, while a genuinely non-exhaustive
 /// match (an `Int` match, or an enum match missing a variant) still gets a clear error.
 /// True if `cases` already covers every combination of enum variants across all
@@ -5017,7 +5017,7 @@ fn compileVariantConstructorArm(
 }
 /// Checks `fields[fpos..]` (a constructor pattern's own sub-patterns, e.g. the `v` in
-/// `Some(v)`, or — recursively — the `Some(v)` in `Wrap(Some(v))`) against the
+/// `Next(v)`, or — recursively — the `Next(v)` in `Wrap(Next(v))`) against the
 /// already-loaded value in `container_local`, one field at a time. Once every field
 /// has matched, calls `on_match` (typically: proceed to the next top-level subject
 /// position). A mismatch at any field — at any nesting depth — falls through to
@@ -5148,7 +5148,7 @@ fn compileFieldPatterns(
         }
         ast::CasePattern::Name(n) => {
             // An uppercase, payload-free variant name used as a field pattern (e.g.
-            // matching a nested `None` rather than binding a name to it).
+            // matching a nested `End` rather than binding a name to it).
             ctx.enum_variants
                 .get(n)
                 .ok_or_else(|| format!("codegen: unknown enum variant '{}'", n))?;
@@ -5383,8 +5383,8 @@ fn compileExpr(
         ast::Expr::Paren(inner) => {
             compileExpr(inner, body, ctx, state)?;
         }
-        // `expr?` — `ref.test` decides Ok/Some (fall through, extract the
+        // `expr?` — `ref.test` decides Ok (fall through, extract the
-        // field) vs Err/None (return the already-constructed value AS-IS,
+        // field) vs Err (return the already-constructed value AS-IS,
         // no reconstruction needed). The `then`/`else` branches don't need to
         // agree in wasm's usual sense: after `return`, the rest of that
         // branch is unreachable, so the validator accepts the `if`'s single
@@ -5499,7 +5499,7 @@ fn compileExpr(
             }
             Instruction::End.encode(body);
         }
-        // `left ?: right` — same `ref.test`/scratch-local narrowing as `Try`
+        // `left ?? right` — same `ref.test`/scratch-local narrowing as `Try`
         // above, but both branches produce an ordinary value (no `return`):
         // the failure branch compiles `right` (already unified against the
         // success field's type by the checker), the success branch extracts
@@ -5723,7 +5723,7 @@ fn compileExpr(
                 },
                 // Bool/class/enum values are wasm-gc refs — `==`/`!=` compares
                 // reference identity via `ref.eq`. That's exactly right for a
-                // payload-free singleton (`None`/`True`/`False`, this migration
+                // payload-free singleton (`End`/`True`/`False`, this migration
                 // plan's Decision 2) and for class-instance identity.
                 // Ordering a ref type has no meaning and was never valid.
                 _ => match &c.op {
@@ -6002,7 +6002,7 @@ fn compileExpr(
             compileExpr(&synthetic, body, ctx, state)?;
         }
         // A NAMED-payload enum variant construction (`Circle(radius: 5)`, as
-        // opposed to the positional/generic-payload form `Some[T]` — constructed
+        // opposed to the positional/generic-payload form `Next(T)` — constructed
         // via `Expr::FnCall` instead, elsewhere) — mirrors `plum-checker`'s own
         // `inferClassCallRaw` handling of the same call shape. Against the
         // variant's own GC struct type (`gc_types.variant_type_idx`), matched by
@@ -6342,8 +6342,8 @@ fn compileExpr(
     Ok(())
 }
-/// Compiles a variant-construction call. A payload-free variant (`None`, called as
+/// Compiles a variant-construction call. A payload-free variant (`End`, called as
-/// `None()` rather than used bare) is its pre-allocated singleton global. A payload
+/// `End()` rather than used bare) is its pre-allocated singleton global. A payload
 /// variant pushes its field values in order and does `struct.new` into its own
 /// concrete variant type.
 /// Compiles the missing TRAILING arguments of a call to `func_key` (a plain

plum-wasm-codegen/tests/codegen_tests.rs CHANGED Viewed

@@ -545,7 +545,7 @@ fn wasmtimeGcConfigSupportsSubtypingRefTestAndNullableSelfReferentialFields() {
     // Deeper empirical check: enum-variant subtyping (abstract supertype + concrete
     // subtypes in one `rec` group), ref.test-based dispatch, ref.cast to narrow to a
     // subtype, and a nullable field that references the struct's OWN type (the
-    // Node.next: Option[Node] shape List needs) — all in one hand-encoded module,
+    // Node.next: Link[Node] shape List needs) — all in one hand-encoded module,
     // bypassing plum entirely.
     use wasm_encoder::*;
@@ -553,8 +553,8 @@ fn wasmtimeGcConfigSupportsSubtypingRefTestAndNullableSelfReferentialFields() {
     let mut types = TypeSection::new();
     // rec group: type 0 = abstract enum supertype (empty struct, non-final so it can
-    // be subtyped); type 1 = concrete "Some"-like subtype with one i32 payload field;
+    // be subtyped); type 1 = concrete "Next"-like subtype with one i32 payload field;
-    // type 2 = concrete "None"-like subtype (empty, no payload).
+    // type 2 = concrete "End"-like subtype (empty, no payload).
     types.ty().rec(vec![
         SubType {
             is_final: false,
@@ -619,7 +619,7 @@ fn wasmtimeGcConfigSupportsSubtypingRefTestAndNullableSelfReferentialFields() {
         },
     }]);
-    // type 4: () -> i32 — constructs a "Some"-like subtype (type 1) holding 42,
+    // type 4: () -> i32 — constructs a "Next"-like subtype (type 1) holding 42,
     // stores it as the supertype (type 0), ref.tests it against type 1, then
     // ref.casts and struct.gets the payload back out. Also builds a 2-node linked
     // list (type 3) and confirms unlinking (overwriting `next` with ref.null) and
@@ -653,7 +653,7 @@ fn wasmtimeGcConfigSupportsSubtypingRefTestAndNullableSelfReferentialFields() {
     let locals_super = 0u32;
     let locals_node = 1u32;
-    // local_super = Some(42) (as the supertype)
+    // local_super = Next(42) (as the supertype)
     f.instruction(&Instruction::I32Const(42));
     f.instruction(&Instruction::StructNew(1));
     f.instruction(&Instruction::LocalSet(locals_super));
@@ -722,7 +722,7 @@ fn wasmtimeGcConfigSupportsSubtypingRefTestAndNullableSelfReferentialFields() {
 #[test]
 fn wasmtimeGcConfigAllowsStructNewInGlobalConstExpr() {
     // Decision 2 of the wasm-gc migration plan pre-allocates payload-free enum
-    // variants (True/False/None/...) once as globals. Confirm a global's
+    // variants (True/False/End/...) once as globals. Confirm a global's
     // initializer expression can directly use struct.new (not just i32.const/
     // ref.null), or the plan needs a `start` function fallback instead.
     use wasm_encoder::*;