9c5f64a | plum | pyrossh

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

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

9c5f64a — Peter John 2026-10-25T16:00:23+05:30

feat(checker): structural tag-union types and Roc-style ? checking

Files changed (5) hide show

plum-checker/src/lib.rs +310 -26
plum-checker/src/monomorphize.rs +4 -1
plum-checker/src/types.rs +14 -0
plum-checker/tests/checker_tests.rs +328 -1
plum-wasm-codegen/src/lib.rs +2 -2

plum-checker/src/lib.rs CHANGED Viewed

@@ -21,10 +21,125 @@ pub fn plumTypeFromName(name: &str) -> PlumType {
         "Byte" => PlumType::TByte,
         "[]Byte" => PlumType::TByteSlice,
         "Unit" => PlumType::TUnit,
+        other if other.starts_with('[') && !other.starts_with("[]") && other.ends_with(']') => {
+            parseTagUnion(other).unwrap_or_else(|| PlumType::TNamed(other.to_string()))
+        }
         other => PlumType::TNamed(other.to_string()),
     }
 }
+/// Splits `s` on `sep` occurring at bracket/paren depth 0 (so a nested tag
+/// union or payload never splits its parent). `[]` (slice prefix) is neutral.
+fn splitTopLevel(s: &str, sep: char) -> Vec<&str> {
+    let mut parts = Vec::new();
+    let mut depth = 0i32;
+    let mut start = 0;
+    let bytes: Vec<(usize, char)> = s.char_indices().collect();
+    let mut i = 0;
+    while i < bytes.len() {
+        let (idx, c) = bytes[i];
+        match c {
+            '[' if bytes.get(i + 1).map(|b| b.1) == Some(']') => i += 1,
+            '[' | '(' => depth += 1,
+            ']' | ')' => depth -= 1,
+            c if c == sep && depth == 0 => {
+                parts.push(&s[start..idx]);
+                start = idx + c.len_utf8();
+            }
+            _ => {}
+        }
+        i += 1;
+    }
+    parts.push(&s[start..]);
+    parts
+}
+/// Parses a canonical tag-union string (`[A,B(Str)]`) into `PlumType::TTags`.
+fn parseTagUnion(s: &str) -> Option<PlumType> {
+    let inner = s.strip_prefix('[')?.strip_suffix(']')?;
+    let mut tags = BTreeMap::new();
+    if inner.is_empty() {
+        return Some(PlumType::TTags(tags));
+    }
+    for seg in splitTopLevel(inner, ',') {
+        let seg = seg.trim();
+        match seg.find('(') {
+            Some(p) => {
+                let name = seg[..p].trim().to_string();
+                let payload = seg[p + 1..].strip_suffix(')')?;
+                tags.insert(name, Some(Box::new(plumTypeFromName(payload.trim()))));
+            }
+            None => {
+                tags.insert(seg.to_string(), None);
+            }
+        }
+    }
+    Some(PlumType::TTags(tags))
+}
+/// Replaces every tag-union segment (`[...]`, but not the `[]Byte` slice
+/// spelling) of a mangled name with `Tags`, so specializations that differ
+/// only in their tag unions share one runtime type:
+/// `erasedEnumName("Try$Int$[A,B(Str)]") == "Try$Int$Tags"`.
+pub fn erasedEnumName(name: &str) -> String {
+    let chars: Vec<char> = name.chars().collect();
+    let mut out = String::new();
+    let mut i = 0;
+    while i < chars.len() {
+        if chars[i] == '[' && chars.get(i + 1) != Some(&']') {
+            let mut depth = 0;
+            while i < chars.len() {
+                match chars[i] {
+                    '[' => depth += 1,
+                    ']' => depth -= 1,
+                    _ => {}
+                }
+                i += 1;
+                if depth == 0 {
+                    break;
+                }
+            }
+            out.push_str("Tags");
+        } else {
+            out.push(chars[i]);
+            i += 1;
+        }
+    }
+    out
+}
+/// True when two mangled specialization names (`Try$Int$[A,B]`) are identical
+/// except for their tag-union segments and every `actual` union is a subset of
+/// the matching `expected` one (E is covariant).
+pub fn tagUnionSegmentsCompatible(expected: &str, actual: &str, ctx: &CheckCtx) -> bool {
+    let e_segs = splitTopLevel(expected, '$');
+    let a_segs = splitTopLevel(actual, '$');
+    if e_segs.len() != a_segs.len() || e_segs.len() < 2 {
+        return false;
+    }
+    let mut saw_union = false;
+    for (e, a) in e_segs.iter().zip(a_segs.iter()) {
+        if e == a {
+            continue;
+        }
+        let both_unions = e.starts_with('[')
+            && !e.starts_with("[]")
+            && a.starts_with('[')
+            && !a.starts_with("[]");
+        if !both_unions {
+            return false;
+        }
+        saw_union = true;
+        if unify(&plumTypeFromName(e), &plumTypeFromName(a), ctx).is_err() {
+            return false;
+        }
+    }
+    saw_union
+}
+/// Reserved `TypeEnv` key holding the enclosing function's declared return type.
+const RETURN_KEY: &str = "$return";
 pub fn plumTypeFromAst(ty: &ast::Type) -> PlumType {
     plumTypeFromName(&ty.name)
 }
@@ -82,6 +197,35 @@ pub fn unify(t1: &PlumType, t2: &PlumType, ctx: &CheckCtx) -> Result<(), String>
         (PlumType::TByteSlice, PlumType::TByteSlice) => Ok(()),
         (PlumType::TUnit, PlumType::TUnit) => Ok(()),
         (PlumType::TNamed(a), PlumType::TNamed(b)) if a == b => Ok(()),
+        // Tag-union subtyping: every tag of `actual` must exist in `expected`
+        // with a unifying payload.
+        (PlumType::TTags(exp), PlumType::TTags(act)) => {
+            for (tag, act_payload) in act {
+                match (exp.get(tag), act_payload) {
+                    (None, _) => {
+                        return Err(format!(
+                            "type mismatch: expected {}, found {} (tag '{}' is not allowed)",
+                            t1, t2, tag
+                        ))
+                    }
+                    (Some(None), None) => {}
+                    (Some(Some(ep)), Some(ap)) => unify(ep, ap, ctx)?,
+                    _ => {
+                        return Err(format!(
+                            "type mismatch: expected {}, found {} (tag '{}' payload differs)",
+                            t1, t2, tag
+                        ))
+                    }
+                }
+            }
+            Ok(())
+        }
+        // Two specializations differing only in their tag-union segments.
+        (PlumType::TNamed(a), PlumType::TNamed(b))
+            if a != b && tagUnionSegmentsCompatible(a, b, ctx) =>
+        {
+            Ok(())
+        }
         // A bare enum variant name (`Red`) can be used directly as a type — e.g.
         // a fn param `v: Red` — meaning "a `Color` value that is specifically
         // the `Red` variant". A variant's OWN constructions/references always
@@ -705,6 +849,8 @@ fn checkFn(f: &ast::Fn, global_env: &TypeEnv, ctx: &CheckCtx) -> Vec<CheckError>
         .as_ref()
         .map(plumTypeFromAst)
         .unwrap_or(PlumType::TUnit);
+    // Reserved env key read by `?` (see `inferExpr`'s `Try` arm); closures remove it.
+    env.insert(RETURN_KEY.to_string(), TypeScheme::mono(declared_ret.clone()));
     match &f.body {
         ast::FnBody::Expr(e) => match inferExpr(e, &env, ctx) {
@@ -1054,8 +1200,22 @@ fn checkStmt(
             errors.append(&mut checkMatch(m, env, declared_ret, fn_name, fn_pos, ctx));
         }
         ast::Stmt::Break | ast::Stmt::Continue | ast::Stmt::Todo => {}
-        // Real semantics (Str check) land in T2.
-        ast::Stmt::Crash(_) => {}
+        ast::Stmt::Crash(e) => match inferExpr(e, env, ctx) {
+            Ok(t) => {
+                if let Err(msg) = unify(&PlumType::TStr, &t, ctx) {
+                    errors.push(CheckError::at(
+                        fn_pos.0,
+                        fn_pos.1,
+                        format!("fn '{}': crash message must be Str: {}", fn_name, msg),
+                    ));
+                }
+            }
+            Err(msg) => errors.push(CheckError::at(
+                fn_pos.0,
+                fn_pos.1,
+                format!("fn '{}': crash: {}", fn_name, msg),
+            )),
+        },
     }
     errors
 }
@@ -1085,6 +1245,50 @@ fn checkMatch(
         return errors; // a subject failed to type — cases can't be checked meaningfully
     }
+    // A match over a tag union without a catch-all must cover every tag.
+    if let [PlumType::TTags(tags)] = subject_types.as_slice() {
+        let mut covered: std::collections::BTreeSet<&str> = Default::default();
+        let mut catch_all = false;
+        for case in &m.cases {
+            if case.guard.is_some() {
+                continue;
+            }
+            match case.patterns.first() {
+                Some(ast::CasePattern::Wildcard) => catch_all = true,
+                Some(ast::CasePattern::Name(n)) => {
+                    if tags.contains_key(n) {
+                        covered.insert(n.as_str());
+                    } else {
+                        catch_all = true; // a binding
+                    }
+                }
+                Some(ast::CasePattern::Class { name, .. }) => {
+                    covered.insert(name.as_str());
+                }
+                _ => {}
+            }
+        }
+        if !catch_all {
+            let missing: Vec<&str> = tags
+                .keys()
+                .map(|k| k.as_str())
+                .filter(|k| !covered.contains(k))
+                .collect();
+            if !missing.is_empty() {
+                errors.push(CheckError::at(
+                    fn_pos.0,
+                    fn_pos.1,
+                    format!(
+                        "fn '{}': non-exhaustive match on {}: missing {}",
+                        fn_name,
+                        PlumType::TTags(tags.clone()),
+                        missing.join(", ")
+                    ),
+                ));
+            }
+        }
+    }
     for case in &m.cases {
         let mut case_env = env.clone();
         if case.patterns.len() == subject_types.len() {
@@ -1281,6 +1485,29 @@ fn checkPattern(
     env: &mut TypeEnv,
     ctx: &CheckCtx,
 ) -> Result<(), String> {
+    if let PlumType::TTags(tags) = subject_ty {
+        let is_upper = |n: &str| n.chars().next().is_some_and(|c| c.is_uppercase());
+        match pat {
+            ast::CasePattern::Name(n) if is_upper(n) => {
+                return match tags.get(n) {
+                    Some(None) => Ok(()),
+                    Some(Some(_)) => Err(format!("tag '{}' carries a payload; write '{}(..)'", n, n)),
+                    None => Err(format!("tag '{}' is not part of {}", n, subject_ty)),
+                };
+            }
+            ast::CasePattern::Class { name, fields } if is_upper(name) => {
+                return match tags.get(name) {
+                    Some(Some(payload)) if fields.len() == 1 => {
+                        checkPattern(&fields[0], payload, env, ctx)
+                    }
+                    Some(Some(_)) => Err(format!("tag '{}' has exactly one payload", name)),
+                    Some(None) => Err(format!("tag '{}' has no payload", name)),
+                    None => Err(format!("tag '{}' is not part of {}", name, subject_ty)),
+                };
+            }
+            _ => {}
+        }
+    }
     match pat {
         ast::CasePattern::Wildcard => Ok(()),
         ast::CasePattern::Int(_) => unify(subject_ty, &PlumType::TInt, ctx),
@@ -1496,7 +1723,7 @@ fn variantBaseName(name: &str) -> &str {
     name.split('$').next().unwrap_or(name)
 }
-/// Finds the "success" (`Ok`/`Some`) and "failure" (`Err`/`None`) variants
+/// Finds the "success" (`Ok`) and "failure" (`Err`) variants
 /// 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
@@ -1513,8 +1740,8 @@ pub fn tryOperatorVariants<'a>(
             continue;
         }
         match variantBaseName(vname) {
-            "Ok" | "Some" => success = Some((vname.as_str(), info)),
+            "Ok" => success = Some((vname.as_str(), info)),
-            "Err" | "None" => failure = Some((vname.as_str(), info)),
+            "Err" => failure = Some((vname.as_str(), info)),
             _ => {}
         }
     }
@@ -1524,6 +1751,19 @@ pub fn tryOperatorVariants<'a>(
     }
 }
+/// True if `n` is an uppercase name that is not a declared type, variant, method
+/// receiver, builtin type or const — i.e. a structural tag literal.
+fn isTagLiteralName(n: &str, ctx: &CheckCtx) -> bool {
+    n.chars().next().is_some_and(|c| c.is_uppercase())
+        && !matches!(
+            n,
+            "Int" | "Float" | "Bool" | "Str" | "Byte" | "Unit" | "Self"
+        )
+        && !ctx.enum_variants.contains_key(n)
+        && !ctx.enum_variants.values().any(|i| i.enum_name == n)
+        && !ctx.methods.keys().any(|(recv, _)| recv == n)
+}
 pub fn inferExpr(expr: &ast::Expr, env: &TypeEnv, ctx: &CheckCtx) -> Result<PlumType, String> {
     match expr {
         ast::Expr::Int(_) => Ok(PlumType::TInt),
@@ -1549,6 +1789,9 @@ pub fn inferExpr(expr: &ast::Expr, env: &TypeEnv, ctx: &CheckCtx) -> Result<Plum
                 // keeps that working without patching every such site.
                 Some(info) if info.enum_name == "Bool" => Ok(PlumType::TBool),
                 Some(info) => Ok(PlumType::TNamed(info.enum_name.clone())),
+                None if isTagLiteralName(n, ctx) => {
+                    Ok(PlumType::TTags(BTreeMap::from([(n.clone(), None)])))
+                }
                 // Unmodeled/builtin type name: allow, codegen will catch.
                 None => Ok(PlumType::TNamed(n.to_string())),
             },
@@ -1565,26 +1808,41 @@ pub fn inferExpr(expr: &ast::Expr, env: &TypeEnv, ctx: &CheckCtx) -> Result<Plum
         // for a case a wrong program still fails on, just less precisely.
         ast::Expr::Try(inner) => {
             let inner_ty = inferExpr(inner, env, ctx)?;
-            match &inner_ty {
+            let name = match &inner_ty {
+                PlumType::TNamed(name) => name,
+                other => return Err(format!("'?' requires a Try value, found {}", other)),
+            };
+            let Some((_, success_info, _, failure_info)) = tryOperatorVariants(name, ctx) else {
+                return Err(format!("'?' requires a Try value, found '{}'", name));
+            };
+            // The failure branch returns early from the enclosing fn, so the
+            // inner error type must fit the fn's declared error type. Closures
+            // (and test blocks) have no `$return` and aren't checked.
+            if let Some(PlumType::TNamed(outer)) = env.get(RETURN_KEY).map(|s| (*s.body).clone()) {
-                PlumType::TNamed(name) => match tryOperatorVariants(name, ctx) {
+                if let Some((_, _, _, outer_failure)) = tryOperatorVariants(&outer, ctx) {
-                    Some((_, success_info, _, _)) => Ok(success_info
+                    if let (Some(inner_err), Some(outer_err)) = (
-                        .field_types
+                        failure_info.field_types.first(),
-                        .first()
-                        .cloned()
-                        .unwrap_or(PlumType::TUnit)),
+                        outer_failure.field_types.first(),
+                    ) {
+                        if unify(outer_err, inner_err, ctx).is_err() {
-                    None => Err(format!(
+                            return Err(format!(
-                        "'?' requires a Result or Option value, found '{}'",
+                                "'?' error type {} is not part of the function's error type {}",
-                        name
+                                inner_err, outer_err
-                    )),
+                            ));
-                },
+                        }
-                other => Err(format!(
-                    "'?' requires a Result or Option value, found {}",
-                    other
-                )),
+                    }
+                }
             }
+            Ok(success_info
+                .field_types
+                .first()
+                .cloned()
+                .unwrap_or(PlumType::TUnit))
         }
         ast::Expr::Closure(cl) => {
             let mut closure_env = env.clone();
+            // A `?` inside a closure returns from the closure, not the outer fn.
+            closure_env.remove(RETURN_KEY);
             let param_names: std::collections::HashSet<&str> =
                 cl.params.iter().map(|s| s.as_str()).collect();
             let mut resolved_from_usage: BTreeMap<String, PlumType> = BTreeMap::new();
@@ -1657,6 +1915,16 @@ pub fn inferExpr(expr: &ast::Expr, env: &TypeEnv, ctx: &CheckCtx) -> Result<Plum
         ast::Expr::Compare(c) => {
             let lt = inferExpr(&c.left, env, ctx)?;
             let rt = inferExpr(&c.right, env, ctx)?;
+            if let (PlumType::TTags(l), PlumType::TTags(r)) = (&lt, &rt) {
+                // Tag equality compares ids only, so payload tags can't be compared.
+                if l.values().chain(r.values()).any(|p| p.is_some()) {
+                    return Err(format!(
+                        "compare op: cannot compare tag unions with payload tags ({} vs {})",
+                        lt, rt
+                    ));
+                }
+                return Ok(PlumType::TBool);
+            }
             unify(&lt, &rt, ctx).map_err(|e| format!("compare op: {}", e))?;
             Ok(PlumType::TBool)
         }
@@ -1668,9 +1936,9 @@ pub fn inferExpr(expr: &ast::Expr, env: &TypeEnv, ctx: &CheckCtx) -> Result<Plum
             unify(&tt, &et, ctx).map_err(|e| format!("ternary branches: {}", e))?;
             Ok(tt)
         }
-        // `left ?: right` — unlike `?`, a plain expression (no early return),
+        // `left ?? right` — unlike `?`, a plain expression (no early return),
         // so (unlike `Try` above) it's fully validated here: `right` must
-        // unify with `left`'s success (`Ok`/`Some`) field type.
+        // unify with `left`'s success (`Ok`) field type.
         ast::Expr::Elvis(e) => {
             let left_ty = inferExpr(&e.left, env, ctx)?;
             let success_ty = match &left_ty {
@@ -1682,20 +1950,20 @@ pub fn inferExpr(expr: &ast::Expr, env: &TypeEnv, ctx: &CheckCtx) -> Result<Plum
                         .unwrap_or(PlumType::TUnit),
                     None => {
                         return Err(format!(
-                            "'?:' requires a Result or Option value, found '{}'",
+                            "'??' requires a Try value, found '{}'",
                             name
                         ))
                     }
                 },
                 other => {
                     return Err(format!(
-                        "'?:' requires a Result or Option value, found {}",
+                        "'??' requires a Try value, found {}",
                         other
                     ))
                 }
             };
             let right_ty = inferExpr(&e.right, env, ctx)?;
-            unify(&success_ty, &right_ty, ctx).map_err(|e| format!("'?:' branches: {}", e))?;
+            unify(&success_ty, &right_ty, ctx).map_err(|e| format!("'??' branches: {}", e))?;
             Ok(success_ty)
         }
         ast::Expr::FnCall(call) => {
@@ -1888,6 +2156,22 @@ pub fn inferExpr(expr: &ast::Expr, env: &TypeEnv, ctx: &CheckCtx) -> Result<Plum
                     }
                 }
                 Ok(_) => Err(format!("'{}' is not a function", call.name)),
+                Err(_) if isTagLiteralName(&call.name, ctx) && call.args.len() <= 1 => {
+                    // `Bad(x)` — an undeclared uppercase name applied to one arg is
+                    // a tag literal with a payload.
+                    let payload = match call.args.first() {
+                        Some(arg) => {
+                            let arg_expr = match arg {
+                                ast::Arg::Positional(e) => e,
+                                ast::Arg::Keyword { value, .. } => value,
+                                ast::Arg::Pair { value, .. } => value,
+                            };
+                            Some(Box::new(inferExpr(arg_expr, env, ctx)?))
+                        }
+                        None => None,
+                    };
+                    Ok(PlumType::TTags(BTreeMap::from([(call.name.clone(), payload)])))
+                }
                 Err(_) => Ok(PlumType::TVar("_".to_string())), // unknown fn: allow, codegen will catch
             }
         }

plum-checker/src/monomorphize.rs CHANGED Viewed

@@ -151,7 +151,10 @@ fn plumTypeToAstType(t: &PlumType) -> ast::Type {
         PlumType::TByteSlice => "[]Byte".to_string(),
         PlumType::TUnit => "Unit".to_string(),
         PlumType::TNamed(n) => n.clone(),
+        PlumType::TVar(_)
+        | PlumType::TFun(_, _)
+        | PlumType::TVariadic(_)
-        PlumType::TVar(_) | PlumType::TFun(_, _) | PlumType::TVariadic(_) => t.to_string(),
+        | PlumType::TTags(_) => t.to_string(),
     };
     ast::Type {
         name,

plum-checker/src/types.rs CHANGED Viewed

@@ -22,6 +22,10 @@ pub enum PlumType {
     /// a body is as a `for` loop's iterable — no other `unify`/`inferExpr` arm
     /// handles it, so any other use is a type error by construction.
     TVariadic(Box<PlumType>),
+    /// A structural tag-union type `[A, B(Str)]`: tag name -> optional payload type.
+    /// `Display` is the canonical string (sorted, no spaces) the parser also
+    /// produces for the type annotation, so mangled names round-trip.
+    TTags(BTreeMap<String, Option<Box<PlumType>>>),
 }
 impl std::fmt::Display for PlumType {
@@ -41,6 +45,16 @@ impl std::fmt::Display for PlumType {
             }
             PlumType::TNamed(n) => write!(f, "{}", n),
             PlumType::TVariadic(inner) => write!(f, "...{}", inner),
+            PlumType::TTags(tags) => {
+                let parts: Vec<String> = tags
+                    .iter()
+                    .map(|(n, p)| match p {
+                        Some(t) => format!("{}({})", n, t),
+                        None => n.clone(),
+                    })
+                    .collect();
+                write!(f, "[{}]", parts.join(","))
+            }
         }
     }
 }

plum-checker/tests/checker_tests.rs CHANGED Viewed

@@ -1,6 +1,9 @@
 #![allow(non_snake_case)]
 use plum_checker::types::*;
+use plum_checker::{
-use plum_checker::{checkSource, plumTypeFromAst, unify, CheckCtx};
+    checkSource, erasedEnumName, plumTypeFromAst, plumTypeFromName, tagUnionSegmentsCompatible,
+    unify, CheckCtx,
+};
 use plum_core::ast::Type as AstType;
 use plum_core::{ast::*, AstParser};
@@ -1299,3 +1302,327 @@ fun bad() -> Int =
         errs
     );
 }
+// ---------------------------------------------------------------------------
+// Roc-style tag unions + `Try` (T2). Sources define a local `Try` inline.
+// ---------------------------------------------------------------------------
+/// Like `parse`, but asserts the parse produced no error nodes.
+fn parseClean(src: &str) -> Source {
+    let mut parser = tree_sitter::Parser::new();
+    parser
+        .set_language(&tree_sitter_plum::LANGUAGE.into())
+        .unwrap();
+    let tree = parser.parse(src, None).unwrap();
+    assert!(
+        !tree.root_node().has_error(),
+        "embedded test source has parse errors:\n{}",
+        src
+    );
+    AstParser::new(src).parseSource(tree.root_node())
+}
+const TRY_DEF: &str = "\
+enum Try[T, E] =
+  | Ok(T)
+  | Err(E)
+  fun mapErr(self, cb: fn(E) -> F) -> Try[T, F] =
+    match self
+      Ok(v) =>
+        return Ok(v)
+      Err(e) =>
+        return Err(cb(e))
+";
+fn checkTry(body: &str) -> Result<(), Vec<CheckError>> {
+    checkSource(&parseClean(&format!("{}{}", TRY_DEF, body)))
+}
+fn errText(r: Result<(), Vec<CheckError>>) -> String {
+    r.unwrap_err()
+        .iter()
+        .map(|e| e.message.clone())
+        .collect::<Vec<_>>()
+        .join(" | ")
+}
+#[test]
+fn tagsTypeDisplayAndRoundTrip() {
+    let t = plumTypeFromName("[A,B(Str)]");
+    match &t {
+        PlumType::TTags(m) => {
+            assert_eq!(m.len(), 2);
+            assert!(m["A"].is_none());
+            assert_eq!(m["B"].as_deref(), Some(&PlumType::TStr));
+        }
+        other => panic!("expected TTags, got {:?}", other),
+    }
+    assert_eq!(t.to_string(), "[A,B(Str)]");
+    assert_eq!(plumTypeFromName("[]Byte"), PlumType::TByteSlice);
+}
+#[test]
+fn tagsSubsetUnify() {
+    let ctx = emptyCtx();
+    let small = plumTypeFromName("[A]");
+    let big = plumTypeFromName("[A,B(Str)]");
+    assert!(unify(&big, &small, &ctx).is_ok());
+    assert!(unify(&small, &big, &ctx).is_err());
+    assert!(unify(&big, &plumTypeFromName("[B(Int)]"), &ctx).is_err());
+}
+#[test]
+fn nested_union_in_payload() {
+    let ctx = emptyCtx();
+    // Brackets inside a payload must not split the outer segment list.
+    assert!(tagUnionSegmentsCompatible(
+        "Try$Int$[A(Try$Int$[X,Y])]",
+        "Try$Int$[A(Try$Int$[X])]",
+        &ctx
+    ));
+    assert!(!tagUnionSegmentsCompatible(
+        "Try$Int$[A(Try$Int$[X])]",
+        "Try$Int$[A(Try$Int$[Z])]",
+        &ctx
+    ));
+    assert!(tagUnionSegmentsCompatible("Try$Int$[A,B]", "Try$Int$[A]", &ctx));
+    assert!(!tagUnionSegmentsCompatible("Try$Int$[A]", "Try$Int$[A,B]", &ctx));
+    // Non-tag segments must match exactly; arity must match.
+    assert!(!tagUnionSegmentsCompatible("Try$Int$[A]", "Try$Str$[A]", &ctx));
+    assert!(!tagUnionSegmentsCompatible("Try$Int$[A]", "Try$Int", &ctx));
+    assert_eq!(
+        erasedEnumName("Try$Int$[A,B(Try$Int$[X])]"),
+        "Try$Int$Tags"
+    );
+    assert_eq!(erasedEnumName("Try$[A]$[B,C]"), "Try$Tags$Tags");
+    assert_eq!(erasedEnumName("List$[]Byte"), "List$[]Byte");
+}
+#[test]
+fn tryOperatorVariantsOnlyOkErr() {
+    let src = "\
+enum Opt =
+  | Some(Int)
+  | None
+";
+    let source = parseClean(src);
+    let (_, methods, variants, params) = plum_checker::buildGlobalTables(&source);
+    let min = plum_checker::buildMinRequiredArgs(&source);
+    let ctx = CheckCtx {
+        methods: &methods,
+        enum_variants: &variants,
+        enum_params: &params,
+        min_required: &min,
+    };
+    assert!(plum_checker::tryOperatorVariants("Opt", &ctx).is_none());
+}
+#[test]
+fn question_mark_rejects_unlisted_tag() {
+    let r = checkTry(
+        "\
+fun g() -> Try[Int, [B]] =
+  Err(B)
+fun f() -> Try[Int, [A]] =
+  x := g()?
+  Ok(x)
+",
+    );
+    let msg = errText(r);
+    assert!(msg.contains("[B]"), "got: {}", msg);
+    assert!(msg.contains("[A]"), "got: {}", msg);
+}
+#[test]
+fn question_mark_widens() {
+    let r = checkTry(
+        "\
+fun g() -> Try[Int, [A]] =
+  Err(A)
+fun f() -> Try[Int, [A, B]] =
+  x := g()?
+  Ok(x)
+",
+    );
+    assert!(r.is_ok(), "got {:?}", r.err());
+}
+#[test]
+fn question_mark_different_ok_types_check() {
+    let r = checkTry(
+        "\
+fun g() -> Try[Int, [A]] =
+  Err(A)
+fun f() -> Try[Str, [A, B]] =
+  x := g()?
+  Ok(\"v\")
+",
+    );
+    assert!(r.is_ok(), "got {:?}", r.err());
+}
+#[test]
+fn closure_question_mark_no_return_check() {
+    // The closure's own `?` must not be checked against f's `[A]` return union.
+    let r = checkTry(
+        "\
+fun g() -> Try[Int, [B]] =
+  Err(B)
+fun f() -> Try[Int, [A]] =
+  h := || g()?
+  Ok(1)
+",
+    );
+    assert!(r.is_ok(), "got {:?}", r.err());
+}
+#[test]
+fn function_return_widens_try_value() {
+    let r = checkTry(
+        "\
+fun g() -> Try[Int, [A]] =
+  Err(A)
+fun f() -> Try[Int, [A, B(Str)]] =
+  g()
+",
+    );
+    assert!(r.is_ok(), "got {:?}", r.err());
+}
+#[test]
+fn tag_literal_with_payload_and_wrong_payload() {
+    assert!(checkTry("fun f() -> Try[Int, [Bad(Str)]] =\n  Err(Bad(\"x\"))\n").is_ok());
+    assert!(checkTry("fun f() -> Try[Int, [Bad(Str)]] =\n  Err(Bad(5))\n").is_err());
+    // Typos are caught by the declared union.
+    assert!(checkTry("fun f() -> Try[Int, [Bad]] =\n  Err(Bda)\n").is_err());
+}
+#[test]
+fn match_exhaustive_tags() {
+    let ok = checkTry(
+        "\
+fun f(t: [A, B(Str)]) -> Int =
+  match t
+    A => 1
+    B(s) => 2
+",
+    );
+    assert!(ok.is_ok(), "got {:?}", ok.err());
+    let missing = errText(checkTry(
+        "\
+fun f(t: [A, B(Str)]) -> Int =
+  match t
+    A => 1
+",
+    ));
+    assert!(
+        missing.contains("non-exhaustive match on [A,B(Str)]: missing B"),
+        "got: {}",
+        missing
+    );
+    let wild = checkTry(
+        "\
+fun f(t: [A, B(Str)]) -> Int =
+  match t
+    A => 1
+    _ => 2
+",
+    );
+    assert!(wild.is_ok(), "got {:?}", wild.err());
+    let unknown = checkTry(
+        "\
+fun f(t: [A, B]) -> Int =
+  match t
+    A => 1
+    C => 3
+    _ => 2
+",
+    );
+    assert!(unknown.is_err());
+}
+#[test]
+fn nested_tag_pattern_in_err() {
+    let r = checkTry(
+        "\
+fun f(r: Try[Int, [NotFound, Bad(Int)]]) -> Int =
+  match r
+    Ok(v) => v
+    Err(NotFound) => 0
+    Err(Bad(n)) => n
+",
+    );
+    assert!(r.is_ok(), "got {:?}", r.err());
+}
+#[test]
+fn eq_rejects_payload_tags() {
+    let ok = checkTry("fun f(a: [A, B], b: [A, B]) -> Bool =\n  a == b\n");
+    assert!(ok.is_ok(), "got {:?}", ok.err());
+    let lit = checkTry("fun f() -> Bool =\n  A == B\n");
+    assert!(lit.is_ok(), "got {:?}", lit.err());
+    let bad = errText(checkTry(
+        "fun f(a: [A, B(Str)], b: [A, B(Str)]) -> Bool =\n  a == b\n",
+    ));
+    assert!(bad.contains("payload"), "got: {}", bad);
+}
+#[test]
+fn unknown_lowercase_still_error() {
+    let r = checkTry("fun f() -> Int =\n  nope\n");
+    assert!(r.is_err());
+    assert!(errText(r).contains("undefined name 'nope'"));
+}
+#[test]
+fn crash_requires_str() {
+    assert!(checkTry("fun f() -> Int =\n  crash \"boom\"\n").is_ok());
+    let bad = errText(checkTry("fun f() -> Int =\n  crash 5\n"));
+    assert!(bad.contains("Str"), "got: {}", bad);
+}
+#[test]
+fn elvis_defaults_try_value() {
+    let ok = checkTry(
+        "\
+fun g() -> Try[Int, [A]] =
+  Err(A)
+fun f() -> Int =
+  g() ?? 7
+",
+    );
+    assert!(ok.is_ok(), "got {:?}", ok.err());
+    let bad = checkTry(
+        "\
+fun g() -> Try[Int, [A]] =
+  Err(A)
+fun f() -> Int =
+  g() ?? \"x\"
+",
+    );
+    assert!(bad.is_err());
+}
+#[test]
+fn try_closure_maps_error() {
+    let r = checkTry(
+        "\
+fun g() -> Try[Int, [B]] =
+  Err(B)
+fun f() -> Try[Int, [Mapped]] =
+  x := g() ? |e| Mapped
+  Ok(x)
+",
+    );
+    assert!(r.is_ok(), "got {:?}", r.err());
+}

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

@@ -649,7 +649,7 @@ fn plumTypeToValtype(t: &PlumType) -> ValType {
         // where a closure's exact struct type isn't being constructed/destructured
         // directly (e.g. deciding a local's storage class), matching `TVariadic`'s
         // existing "not modeled as a concrete shape here" treatment.
-        PlumType::TFun(_, _) | PlumType::TVariadic(_) => ValType::Ref(RefType::ANYREF),
+        PlumType::TFun(_, _) | PlumType::TVariadic(_) | PlumType::TTags(_) => ValType::Ref(RefType::ANYREF),
         PlumType::TVar(_) | PlumType::TUnit => ValType::I64,
     }
 }
@@ -755,7 +755,7 @@ fn plumTypeToGcValtype(t: &PlumType, registry: &GcTypeRegistry) -> ValType {
         // TFun (closures) and TVariadic get their own concrete representation once
         // Task 2 (closures/variadic calls) lands — `anyref` is a safe, valid-but-not-
         // yet-meaningful placeholder in the meantime, since nothing consumes it yet.
-        PlumType::TFun(_, _) | PlumType::TVariadic(_) => ValType::Ref(RefType::ANYREF),
+        PlumType::TFun(_, _) | PlumType::TVariadic(_) | PlumType::TTags(_) => ValType::Ref(RefType::ANYREF),
         PlumType::TVar(_) | PlumType::TUnit => ValType::I64,
     }
 }