elly_core/

parse.rs

//! Parsing: Muon tree → Elly AST.
//!
//! A program is a single chain (`<expr>`). Chains are split on the first `&`-prefixed
//! item into an application spine and a trailing abstraction. Comments are dropped.
//!
//! Patterns are faithful AST: `&`-headers and `let` LHSs parse into [`Pattern`] nodes
//! matched directly by the evaluator. Abstractions are `Expr::Abs(Rc<Lambda>)`, where
//! `&p0 &p1 …` runs collect into multi-parameter [`Lambda`]s. Application spines and
//! spread calls flatten into `Expr::App(Box<[Expr]>)`.

use alloc::boxed::Box;
use alloc::rc::Rc;
use alloc::string::String;
use alloc::vec::Vec;

use muon::{Chain, Item, Seq};
use num_bigint::BigInt;

use crate::ast::{Captures, Expr, HomeLeaf, Lambda, MapKey, Pattern, ProtoRef, Text};
use crate::builtins::Builtin;
pub use crate::module::ModuleSyntax;
use crate::module::{ImportDecl, ImportSpec, ModuleData};

/// Copy a source string slice into an owned text leaf.
/// The AST uses owned `Text` rather than borrowing from the Muon source.
fn text(s: &str) -> Text {
    Text::from(s)
}

// TODO: use thiserror?
/// A parse failure: the input is a valid Muon tree but not a well-formed Elly
/// program in this subset.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ParseError {
    /// The top-level sequence held no chain (nothing to evaluate).
    EmptyProgram,
    /// The top-level sequence held more than one chain; top-level sequencing
    /// is deferred (a program is a single expression).
    MultipleExpressions,
    /// A chain reduced to nothing (e.g. only comments).
    EmptyChain,
    /// A `&` binder with no body — `&x` alone is ill-formed (yet).
    AbsWithoutBody,
    /// A `&` prefix on something that is not a well-formed binder header (see
    /// `BadPattern` for the pattern content itself).
    BadBinder,
    /// A binder appeared where an atomic expression was expected. Not reachable
    /// via the split logic, kept so parsing never panics.
    UnexpectedBinder,
    /// A `.` sigil on something that is not a single name/number segment (e.g.
    /// `.(…)`, `.&x`). `.foo` / `.0` are symbols; the record sugar `.(…)` and
    /// other prefixed items are deferred / ill-formed.
    BadSymbol,
    /// A bare `.` used as an atom (`f . g`, a lone `.`). At the Muon layer this
    /// is a `<punct>`; Elly reserves it for a future `.` / `|>` application
    /// combinator, which is deferred.
    CombinatorDeferred,
    /// `_` used as a reference. `_` is the discard pattern (a binder that binds
    /// nothing), never a name that can be read back.
    DiscardReference,
    /// A `&`-binder tried to introduce a name starting with `__`. Such names are
    /// reserved for builtins / special forms and may be referenced but not bound.
    ReservedName,
    /// A `<sym>` that begins like a number but is not a valid integer literal
    /// (`1a`, `0xZZ`, `1__2`, `0x`). Since a `<name>` may not start with a digit,
    /// a digit-leading sym must be a well-formed `<int>` or it is an error.
    MalformedNumber,
    /// A stray `:` / `=` (or other) `<punct>` item at atom position. Muon parses
    /// this punctuation, but outside a `let` binding (`=`) or a map entry (`:`)
    /// it has no atomic reading. (A `#{…}` map literal and a `#[…]` list value are
    /// their own atoms; the bare `{…}` / `[…]` forms are rejected, not deferred.)
    PunctAtAtom,
    /// A map entry (`<braces>` chain) whose key is missing or malformed: no `:`
    /// after the key, or a key item that is not a bare atom, a `.`-symbol, a `(…)`
    /// computed key, or a `#[…]` / `#{…}` literal key (`{ : 1 }`, `{ foo }`).
    MalformedMapKey,
    /// A `let` not followed by a binder group — `let 1 e`. An *empty* group is not
    /// an error: `let () e` binds nothing and is `e` (see `parse_let`).
    LetMissingBinders,
    /// A `let (…)` with nothing after the binder group; the body is required.
    LetMissingBody,
    /// A `recur` not followed by a binder group — `recur 1 e`. As with `let`, an
    /// empty group is not an error: `recur () e` is `e`.
    RecurMissingBinders,
    /// A `recur (…)` with nothing after the binder group; the body is required.
    RecurMissingBody,
    /// A `recur` binding whose name is already in scope. The group's bindings are
    /// simultaneous, so inside it the name would mean the group's own binding and
    /// never the outer one — the opposite of what the identical `let` line means.
    /// Detected by the resolution pass (`resolve.rs`); carries the offending name.
    RecurShadowsOuter(Text),
    /// A binding inside a `let (…)` group is not `<pattern> "=" <expr>`: missing
    /// or repeated top-level `=`, an empty pattern, or an empty value.
    MalformedBinding,
    /// A keyword (`let`, `with`) used as a reference or a binder. Keywords are
    /// syntax, not names: they may be neither read nor bound.
    ReservedKeyword,
    /// A malformed pattern: an empty pattern, a comma-grouped `(a, b)` used as a
    /// single pattern, a misplaced `...rest`, or any item with no pattern reading.
    BadPattern,
    /// A comparand after `=` / `<` / `>` that is not a single **atom** (a name or
    /// a literal). A pattern is a closed grammar — `= f x`, `< (f x)`, `= [a]`
    /// have no reading; write `= x`, `= 5`, or `.foo`.
    ComparandNotAtom,
    /// A bare **matching literal** used as an entire `&`-header or `let` binding
    /// LHS: a number (`&42`), a symbol (`&.foo`), or a string (`&"foo"`).
    /// Parenthesize it — `&(42)`, `&(.foo)`, `&("foo")`, `let ((42) = v)` — so the
    /// "match this literal" intent is explicit (a bare literal reads as a value, or
    /// as an intended binder). A literal *nested* in `[…]` / `{…}` / `(…)` / an
    /// or-pattern needs no parens.
    BareLiteralHeader,
    /// A `<str>` literal with an **unpaired UTF-16 surrogate** escape (`"\uD83D"`,
    /// a high or low `\uXXXX` not completing a pair). Muon accepts it lexically,
    /// but UTF-8 cannot represent it, so Elly's decode rejects it at parse.
    LoneSurrogate,
    /// A bare top-level `|` in a `let` binding's LHS: `let ((x=.a) | (x=.b) = v)`.
    /// Wrap the or-pattern — `let (((x=.a) | (x=.b)) = v) e` — so it does not
    /// visually compete with the binding's own `=`.
    LetOrUnparenthesized,
    /// An `as <Type>` whose `<Type>` is not one of the closed kinds
    /// `Int Sym List Map Fun`.
    UnknownType,
    /// An or-pattern `(p | q)` whose arms bind different sets of names.
    OrBindersMismatch,
    /// A `|>` pipe combinator with a missing operand — `|> f`, `x |>`, or
    /// `x |> |> f`. Both sides of `|>` must be non-empty.
    MalformedPipe,
    /// A name reference that resolves to no enclosing `&`-binding — a free
    /// variable. Detected by the resolution pass (`resolve.rs`) after parsing,
    /// so it is a *static* error: the program is rejected before it runs, rather
    /// than raising `.unbound_name` at eval. Carries the offending name (spans
    /// are still a TODO). `__`-names never reach here — they are resolved to
    /// [`Expr::Builtin`](crate::Expr) at parse.
    UnboundName(Text),
    /// A module (`parse_module`) binding whose left-hand side is not a single bare
    /// name: a destructuring pattern, a literal, a discard, or a digit-leading
    /// token. Module top-level keys are plain names in v0. A `__…` or keyword LHS
    /// reports [`ParseError::ReservedName`] / [`ParseError::ReservedKeyword`] instead.
    BadModuleItemName,
    /// A module defines the same item name twice, or an `import`'s local name is
    /// also an item name. A name means one thing inside a module, so both are
    /// rejected here. The `Foo = import "spec"` form is the one place a name is
    /// both an import and an item: it is a single declaration, and it makes them
    /// the same thing.
    DuplicateModuleItem,
    /// An `import` that is neither `import "<spec>" as <Name>` nor
    /// `<Name> = import "<spec>"`: a missing `as`, a spec that is not a string
    /// literal, or trailing items. The spec is a literal in a fixed position —
    /// which is what makes a module's imports a static, auditable list — so there
    /// is nothing to compute here.
    MalformedImport,
    /// An `import` somewhere other than a module's top level — today, inside a
    /// [`recur`](crate::Expr::Recur) group. An import is a frame slot the const
    /// stage fills before the module exists, so it can only be written in a
    /// module's own source. Written anywhere else, `import` is an ordinary keyword
    /// and reports [`ParseError::ReservedKeyword`].
    MisplacedImport,
    /// A `const` declaration that is neither `const <name>`, `const (<name> …)`
    /// nor `<name> = const`: a declaration that is not a bare name, a group whose
    /// chains are not bare names, or a **payload** — `const x = 1`, `x = const 1`.
    /// The payload forms are reserved for const-time expressions and rejected
    /// until those exist (see `docs/done/2026-08-13_elly-modules-iotas.md`).
    MalformedConst,
    /// A `const` somewhere other than a module's top level — today, inside a
    /// [`recur`](crate::Expr::Recur) group. A group is built while a program runs
    /// and has no instance of its own to mint against, so an iota can only be
    /// declared in a module's source. Written anywhere else, `const` is an
    /// ordinary keyword and reports [`ParseError::ReservedKeyword`].
    MisplacedConst,
    /// A binder — a pattern binder, a `let` binding, a `recur` binding — taking a
    /// name the enclosing module declares as an **import**. A declaration's name
    /// means one thing over the whole module, so it may not be shadowed from
    /// inside (see `docs/done/2026-08-13_elly-modules-iotas.md`). Carries the name.
    ShadowsImport(Text),
    /// A binder taking a name the enclosing module declares as a `const`
    /// [iota](ParseError::ShadowsImport). Carries the name.
    ShadowsIota(Text),
    /// A `local` declaration that is neither `local <name> = <expr>` nor the
    /// group `local (<name> = <expr> …)`: a left-hand side that is not a bare
    /// name, a group chain that is not a binding, or a missing body. The
    /// head-with-arguments form `local f x = <expr>` lands here too — it is a
    /// template moditem, left open (see `docs/done/2026-08-13_elly-modules-local.md`).
    MalformedLocal,
    /// A `local` somewhere other than a module's top level — today, inside a
    /// [`recur`](crate::Expr::Recur) group, where every binding is private
    /// already, so the keyword would say nothing. Written anywhere else, `local`
    /// is an ordinary keyword and reports [`ParseError::ReservedKeyword`].
    MisplacedLocal,
    /// A binder taking a name the enclosing module declares as a
    /// [`local`](ParseError::ShadowsImport). Carries the name.
    ShadowsLocal(Text),
    /// A binder taking a name the enclosing module — or an enclosing
    /// [`recur`](crate::Expr::Recur) group — declares as an **item**. Carries the
    /// name. This is the direction opposite to
    /// [`RecurShadowsOuter`](ParseError::RecurShadowsOuter), which stops a group
    /// binding from shadowing a name already in scope; together they make a
    /// declared name unshadowable from either side.
    ShadowsItem(Text),
    /// A `__` name the language does not define, in either position it can be
    /// written: a module top-level left-hand side (`__mian = …`) or a reference
    /// in an expression (`__mian`). The `__` namespace belongs to the language —
    /// a source may write the builtins and the **reserved moditems** it defines
    /// and nothing else — so a misspelling fails here, naming the namespace,
    /// rather than becoming an item nobody reads or a name nothing binds.
    /// Carries the name as written.
    UnknownReserved(Text),
    /// A module declaring the same reserved moditem twice (two `__main`s). A
    /// reserved moditem is a single slot, not a table, so there is no second one
    /// to hold. Carries the name.
    DuplicateReserved(Text),
    /// A reserved moditem somewhere other than a module's top level — today,
    /// inside a [`recur`](crate::Expr::Recur) group. A group is an item table,
    /// not a module source, and nothing would ever read the slot. Written
    /// anywhere else, `__main` is an ordinary `__` name and reports
    /// [`UnknownReserved`](ParseError::UnknownReserved).
    MisplacedReserved,
    /// A [home-module leaf](crate::HomeLeaf) — `Self`, `#Self(…)`, `x.Self`, or
    /// the `Self <pat>` pattern — outside a module body. Each reads the module
    /// its body is written in, and there is none: the term is not a module's, or
    /// it is a [`recur`](crate::Expr::Recur) group in a program that is not a
    /// module. One test covers both, since a group is not a module either.
    /// Carries the name — `Self`, the one word every form is spelled with.
    OutsideModule(Text),
    /// An `as <Proto>` pattern whose reference is a `__` name that is not a
    /// **prototype**: a builtin that is no module at all (`as __eq`), or `__Err`,
    /// which is a namespace of operations that no value answers `__proto` with —
    /// so the check could never hold. Rejected here rather than compiled into a
    /// pattern that always refutes. Carries the name.
    NotAPrototype(Text),
    /// A [`&`](muon::Item::Prefixed)-headed **run** (`&x.0`, `&(a, b).0`) — a
    /// binder glued to a following atom with no whitespace. A binder is one
    /// prefixed atom, so the glued tail has no reading; write it spaced
    /// (`&x .0`) to apply, or restructure. See `docs/todo/elly-parse-runs.md` §C.
    BinderRunGlued,
    /// An `<int>`-then-`.<digits>` run — the float-like run `3.14` (Muon groups
    /// the two atoms, see `docs/done/2026-09-08_muon-runs.md`). Float literals do
    /// not exist yet; this holds the notation open for them (a real float is a
    /// later `Num` extension) while giving a clear error now instead of the
    /// runtime `.not_applicable` a spaced `3 .14` projection raises.
    FloatLiteralUnsupported,
    /// A [`#`](muon::Item::Prefixed)-prefixed form other than the three that
    /// read: `#[…]` (a list), `#{…}` (a map), and `#Self(…)` / `#Self …`
    /// (construction). The `#` sigil marks a **literal notation**, and the
    /// remaining shapes — `#<sym>`, `#<str>`, `#(…)`, `#.name` — are reserved
    /// for future literal kinds with no reading yet. A bare `#Self` lands here
    /// as well: construction is a form, not a value, so it may only head a
    /// spine (see `parse_app_spine`). See `docs/todo/elly-syntax-v1.md` §2.
    ReservedLiteralForm,
    /// A bare `[…]` where a list literal or list pattern is written. After the
    /// reshuffle (phase 3), the list literal uses the `#`-prefixed spelling
    /// exclusively: write `#[…]`. See `docs/todo/elly-syntax-v1.md` § 3–5.
    BareListLiteral,
    /// A bare `{…}` carrying a `:`-clause where a map literal or map pattern is
    /// written. After the reshuffle, the map literal uses the `#`-prefixed
    /// spelling exclusively: write `#{…}`. A `:`-clause has no reading in a block
    /// (nothing legal in a block starts `<key> :`), so a brace group with one is
    /// this error in every position; a brace group *without* a `:`-clause is a
    /// block (step 6), and the empty `{}` is the unit value.
    /// See `docs/todo/elly-syntax-v1.md` § 3–5.
    BareMapLiteral,
    /// A block `{…}` whose final clause is a binding (`{ …, x = v }`). A block's
    /// value is its last clause's value and its bindings do not escape, so a
    /// trailing binding would bind a name nothing can read and leave no value to
    /// return — as a `let` with no body does. End the block with an expression.
    /// See `docs/todo/elly-syntax-v1.md` § 5 (review) and step 6.
    BlockTrailingBinding,
    /// A `case` with no `{…}` arm block — `case x` or `case` alone, or a trailing
    /// item that is not a brace group. The block is where the clauses live, so a
    /// `case` without one has nothing to match against and no reading.
    CaseMissingArms,
    /// A `case` subject that is more than one item — `case f x { … }`. The subject
    /// is exactly one item so the arm block's `{…}` is unambiguous; group a
    /// compound subject (`case (f x) { … }`) or pipe it in (`f x |> case { … }`).
    CaseSubjectExtra,
    /// A `case` arm whose chain is not headed by `&` — a clause that is not a
    /// binder. Every arm is `& <pattern> … <body>`; a bare expression is not one.
    ArmNotBinder,
    /// A `case` arm with a pattern (and any guards) but no body after them —
    /// `& x` or `& x when (c)` alone. An arm's body is required.
    ArmMissingBody,
    /// A `when` guard with no `(…)` condition group — `when` at the end of a
    /// header, or `when` followed by something other than a parenthesized group.
    WhenMissingCond,
}

/// Parse a program (single top-level chain) to an expression.
pub fn parse_program<'a>(seq: &Seq<'a>) -> Result<Expr, ParseError> {
    match chain_slices(seq).as_slice() {
        [] => Err(ParseError::EmptyProgram),
        [items] => parse_items(items),
        _ => Err(ParseError::MultipleExpressions),
    }
}

/// Parse a module source's top-level sequence into its declarations.
///
/// Items are single bare names in v0. Imports are mapped to leading frame slots.
/// Bodies are unresolved here (done in [`crate::compile_module`]).
pub fn parse_module<'a>(seq: &Seq<'a>) -> Result<ModuleSyntax, ParseError> {
    let mut items: Vec<(Text, Expr)> = Vec::new();
    let mut imports: Vec<ImportDecl> = Vec::new();
    let mut iotas: Vec<Text> = Vec::new();
    let mut locals: Vec<(Text, Expr)> = Vec::new();
    let mut main: Option<Expr> = None;
    let mut reexported_imports: Vec<Text> = Vec::new();
    let mut reexported_iotas: Vec<Text> = Vec::new();
    for ci in chain_slices(seq) {
        let split = ci.iter().position(|it| matches!(it, Item::Punct("=")));
        if split.is_none() && head_keyword(ci[0]) == Some("import") {
            let (name, spec) = parse_private_import(&ci)?;
            push_import(&mut imports, name, spec)?;
            continue;
        }
        if split.is_none() && head_keyword(ci[0]) == Some("const") {
            for name in parse_const_decl(&ci)? {
                push_iota(&mut iotas, name)?;
            }
            continue;
        }
        if split.is_none() && head_keyword(ci[0]) == Some("local") {
            for (name, body) in parse_local_group(&ci)? {
                push_local(&mut locals, name, body)?;
            }
            continue;
        }
        let eq = split.ok_or(ParseError::MalformedBinding)?;
        if ci[eq + 1..].iter().any(|it| matches!(it, Item::Punct("="))) {
            return Err(ParseError::MalformedBinding);
        }
        let (head, tail) = (&ci[..eq], &ci[eq + 1..]);
        if head.is_empty() || tail.is_empty() {
            return Err(ParseError::MalformedBinding);
        }
        if head.len() > 1 && head_keyword(head[0]) == Some("const") {
            return Err(ParseError::MalformedConst);
        }
        if head.len() > 1 && head_keyword(head[0]) == Some("local") {
            let name = plain_name(&head[1..], ParseError::MalformedLocal)?;
            push_local(&mut locals, name, parse_items(tail)?)?;
            continue;
        }
        if let [Item::Sym(s)] = head {
            if let Some(reserved) = reserved_moditem(s) {
                if main.is_some() {
                    return Err(ParseError::DuplicateReserved(text(reserved)));
                }
                main = Some(parse_items(tail)?);
                continue;
            }
            if s.starts_with("__") {
                return Err(ParseError::UnknownReserved(text(s)));
            }
        }
        let name = plain_name(head, ParseError::BadModuleItemName)?;
        if items.iter().any(|(n, _)| n.as_str() == name.as_str()) {
            return Err(ParseError::DuplicateModuleItem);
        }
        if head_keyword(tail[0]) == Some("import") {
            let spec = parse_import_spec(tail)?;
            push_import(&mut imports, name.clone(), spec)?;
            reexported_imports.push(name.clone());
            items.push((name.clone(), Expr::Name(name)));
            continue;
        }
        if head_keyword(tail[0]) == Some("const") {
            if tail.len() != 1 {
                return Err(ParseError::MalformedConst);
            }
            push_iota(&mut iotas, name.clone())?;
            reexported_iotas.push(name.clone());
            items.push((name.clone(), Expr::Name(name)));
            continue;
        }
        let body = parse_items(tail)?;
        items.push((name, body));
    }
    for imp in &imports {
        if iotas.iter().any(|n| n.as_str() == imp.name.as_str()) {
            return Err(ParseError::DuplicateModuleItem);
        }
        if reexported_imports
            .iter()
            .any(|n| n.as_str() == imp.name.as_str())
        {
            continue;
        }
        if items.iter().any(|(n, _)| n.as_str() == imp.name.as_str()) {
            return Err(ParseError::DuplicateModuleItem);
        }
    }
    for iota in &iotas {
        if reexported_iotas.iter().any(|n| n.as_str() == iota.as_str()) {
            continue;
        }
        if items.iter().any(|(n, _)| n.as_str() == iota.as_str()) {
            return Err(ParseError::DuplicateModuleItem);
        }
    }
    for (name, _) in &locals {
        let taken = items.iter().any(|(n, _)| n.as_str() == name.as_str())
            || iotas.iter().any(|n| n.as_str() == name.as_str())
            || imports.iter().any(|i| i.name.as_str() == name.as_str());
        if taken {
            return Err(ParseError::DuplicateModuleItem);
        }
    }
    Ok(ModuleSyntax {
        imports,
        iotas,
        items,
        locals,
        main,
    })
}

/// The reserved moditems the language defines, as the names a module top-level
/// left-hand side may spell in the `__` namespace. One so far; `__test` and
/// `__doc` are anticipated, and each will be another slot on [`ModuleSyntax`]
/// with a clause here (see `docs/done/2026-08-14_elly-run.md`).
///
/// Answers with the `'static` spelling so the caller reports the *defined* name
/// rather than echoing the source, and `None` for a name that is not one — which
/// the caller turns into [`ParseError::UnknownReserved`] rather than an item.
fn reserved_moditem(name: &str) -> Option<&'static str> {
    match name {
        "__main" => Some("__main"),
        _ => None,
    }
}

/// Record one import, rejecting a name a previous import already took.
fn push_import(
    imports: &mut Vec<ImportDecl>,
    name: Text,
    spec: ImportSpec,
) -> Result<(), ParseError> {
    if imports.iter().any(|i| i.name.as_str() == name.as_str()) {
        return Err(ParseError::DuplicateModuleItem);
    }
    imports.push(ImportDecl { name, spec });
    Ok(())
}

/// Parse `import "<spec>" as <Name>` — the private form, whose whole chain is the
/// declaration — to its name and spec. The keyword may be a bare sym or a glued
/// run head (§D); in the run case only the spec glues into the run (`import"spec"`)
/// while `as <Name>` stays in the chain after it, so the two are concatenated back
/// into the one item stream the spaced form already is.
fn parse_private_import<'a>(ci: &[&Item<'a>]) -> Result<(Text, ImportSpec), ParseError> {
    // Drop the keyword head. When it is a glued run head (§D) the spec sits inside
    // the run (`import"spec"`), but `as <Name>` is space-separated and so stays in
    // the chain after the run — so the run's members and the chain tail concatenate
    // into one `"spec" as Name` stream, the same one the spaced form is.
    let rest: Vec<&Item<'a>> = match ci[0] {
        Item::Run(members) => members[1..]
            .iter()
            .map(|it| it as &Item<'a>)
            .chain(ci[1..].iter().copied())
            .collect(),
        _ => ci[1..].to_vec(),
    };
    match rest.as_slice() {
        [Item::Str(spec), Item::Sym("as"), rest @ ..] if !rest.is_empty() => {
            let name = plain_name(rest, ParseError::BadModuleItemName)?;
            Ok((name, decode_str(spec)?))
        }
        _ => Err(ParseError::MalformedImport),
    }
}

/// Record one iota, rejecting a name a previous `const` already declared.
fn push_iota(iotas: &mut Vec<Text>, name: Text) -> Result<(), ParseError> {
    if iotas.iter().any(|n| n.as_str() == name.as_str()) {
        return Err(ParseError::DuplicateModuleItem);
    }
    iotas.push(name);
    Ok(())
}

/// Parse a private `const` declaration — `const <name>`, or the group form
/// `const (<name> …)` — to the names it declares.
///
/// The group is an ordinary `<parens>` wrapping a `<seq>`, so its names may be
/// newline- or comma-separated and it may carry comments, exactly as a `let`
/// group may. An **empty group declares nothing**, the same degenerate reading
/// `let ()` and `recur ()` take.
fn parse_const_decl<'a>(ci: &[&Item<'a>]) -> Result<Vec<Text>, ParseError> {
    // The keyword may be a bare sym or a glued run head (§D); the declared names
    // are read from what follows it (the run's members in the run case).
    let rest: Vec<&Item<'a>> = match ci[0] {
        Item::Run(members) => members[1..].iter().map(|it| it as &Item<'a>).collect(),
        _ => ci[1..].to_vec(),
    };
    match rest.as_slice() {
        [Item::Parens(seq), ..] => {
            let mut names = Vec::new();
            for c in chain_slices(seq) {
                names.push(plain_name(&c, ParseError::MalformedConst)?);
            }
            Ok(names)
        }
        rest if !rest.is_empty() => Ok(alloc::vec![plain_name(rest, ParseError::MalformedConst)?]),
        _ => Err(ParseError::MalformedConst),
    }
}

/// Record one local, rejecting a name a previous `local` already took.
fn push_local(locals: &mut Vec<(Text, Expr)>, name: Text, body: Expr) -> Result<(), ParseError> {
    if locals.iter().any(|(n, _)| n.as_str() == name.as_str()) {
        return Err(ParseError::DuplicateModuleItem);
    }
    locals.push((name, body));
    Ok(())
}

/// Parse group form `local (<name> = <expr> …)` to its bindings.
///
/// The group is an ordinary `<parens>` wrapping a `<seq>`. An empty group
/// declares nothing. The single form `local x = <expr>` is handled separately.
fn parse_local_group<'a>(ci: &[&Item<'a>]) -> Result<Vec<(Text, Expr)>, ParseError> {
    let seq = match ci[0] {
        Item::Run(members) => {
            let Some(Item::Parens(seq)) = members.get(1) else {
                return Err(ParseError::MalformedLocal);
            };
            seq
        }
        _ => {
            let Some(Item::Parens(seq)) = ci.get(1) else {
                return Err(ParseError::MalformedLocal);
            };
            seq
        }
    };
    let mut bindings = Vec::new();
    for c in chain_slices(seq) {
        let eq = c
            .iter()
            .position(|it| matches!(it, Item::Punct("=")))
            .ok_or(ParseError::MalformedLocal)?;
        let (head, tail) = (&c[..eq], &c[eq + 1..]);
        if head.is_empty() || tail.is_empty() {
            return Err(ParseError::MalformedLocal);
        }
        if tail.iter().any(|it| matches!(it, Item::Punct("="))) {
            return Err(ParseError::MalformedLocal);
        }
        bindings.push((
            plain_name(head, ParseError::MalformedLocal)?,
            parse_items(tail)?,
        ));
    }
    Ok(bindings)
}

/// Parse the `import "<spec>"` RHS of a re-exporting import to its spec.
/// Handles both spaced and glued spellings.
fn parse_import_spec<'a>(tail: &[&Item<'a>]) -> Result<ImportSpec, ParseError> {
    let spec = match tail {
        [_import, Item::Str(spec)] => spec,
        [Item::Run(members)] => match members.as_slice() {
            [_import, Item::Str(spec)] => spec,
            _ => return Err(ParseError::MalformedImport),
        },
        _ => return Err(ParseError::MalformedImport),
    };
    decode_str(spec)
}

/// Parse a single plain name for a binding position.
/// Must be exactly one `<sym>` that is not a keyword, `__` name, discard, or number.
fn plain_name<'a>(items: &[&Item<'a>], bad: ParseError) -> Result<Text, ParseError> {
    match items {
        [Item::Sym(s)] if is_keyword(s) => Err(ParseError::ReservedKeyword),
        [Item::Sym(s)] if s.starts_with("__") => Err(ParseError::ReservedName),
        [Item::Sym(s)] if reads_as_number(s) || *s == "_" => Err(bad),
        [Item::Sym(s)] => Ok(text(s)),
        _ => Err(bad),
    }
}

/// Check if a `<sym>` reads as a number (valid integer or digit-leading).
fn reads_as_number(s: &str) -> bool {
    parse_int(s).is_some() || s.as_bytes()[0].is_ascii_digit()
}

/// Parse a comment-free slice of items.
fn parse_items<'a>(items: &[&Item<'a>]) -> Result<Expr, ParseError> {
    if items.is_empty() {
        return Err(ParseError::EmptyChain);
    }
    // `|>` is the loosest operator: split on the last one to form a left-associative
    // pipe chain over segments.
    match items.iter().rposition(|it| matches!(it, Item::Punct("|>"))) {
        None => parse_segment(items),
        Some(k) => {
            let (left, right) = (&items[..k], &items[k + 1..]);
            if left.is_empty() || right.is_empty() {
                return Err(ParseError::MalformedPipe);
            }
            let l = parse_items(left)?;
            let r = parse_segment(right)?;
            Ok(append_arg(r, l))
        }
    }
}

/// Parse one pipe segment (a `|>`-free slice).
///
/// This is an application spine whose trailing argument may be a `&`/`let`/`recur`
/// binder form. Split points have lowest precedence within the segment.
fn parse_segment<'a>(items: &[&Item<'a>]) -> Result<Expr, ParseError> {
    match items.iter().position(|it| is_split_point(it)) {
        None => parse_app_spine(items),
        Some(0) => match head_keyword(items[0]) {
            Some("let") | Some("recur") => parse_let_or_recur(items[0], items),
            Some("case") => parse_case(items),
            _ => {
                if items.len() == 1 {
                    return Err(ParseError::AbsWithoutBody);
                }
                let inner = match items[0] {
                    Item::Prefixed { sigil: '&', item } => item.as_ref(),
                    _ => return Err(ParseError::UnexpectedBinder),
                };
                if matches!(items.get(1), Some(it) if is_when_kw(it))
                    && !matches!(inner, Item::Parens(_))
                {
                    if is_bare_literal_header(inner) {
                        return Err(ParseError::BareLiteralHeader);
                    }
                    let base = parse_pattern(&[inner])?;
                    let (pat, rest) = peel_when(base, &items[1..])?;
                    if rest.is_empty() {
                        return Err(ParseError::AbsWithoutBody);
                    }
                    let body = parse_segment(rest)?;
                    return Ok(abs(pat, body));
                }
                let body = parse_segment(&items[1..])?;
                build_binder(inner, body)
            }
        },
        Some(k) => {
            let f = parse_segment(&items[..k])?;
            let arg = parse_segment(&items[k..])?;
            Ok(append_arg(f, arg))
        }
    }
}

/// Parse leading `let`/`recur` form, reading the binder group from a glued
/// run or a bare symbol.
fn parse_let_or_recur<'a>(head: &Item<'a>, items: &[&Item<'a>]) -> Result<Expr, ParseError> {
    let is_recur = head_keyword(head) == Some("recur");
    let missing = || {
        if is_recur {
            ParseError::RecurMissingBinders
        } else {
            ParseError::LetMissingBinders
        }
    };
    let (group_item, body_items): (&Item<'_>, &[&Item<'_>]) = match head {
        Item::Run(members) if members.len() == 2 => (&members[1], &items[1..]),
        Item::Run(_) => return Err(missing()),
        _ => (*items.get(1).ok_or_else(missing)?, &items[2..]),
    };
    let group = match group_item {
        Item::Parens(seq) => seq,
        _ => return Err(missing()),
    };
    if is_recur {
        parse_recur_inner(group, body_items)
    } else {
        parse_let_inner(group, body_items)
    }
}

/// Parse `let` body: fold group bindings right-to-left over `body_items`.
///
/// An empty group binds nothing (`let () e` is `e`).
fn parse_let_inner<'a>(group: &Seq<'a>, body_items: &[&Item<'a>]) -> Result<Expr, ParseError> {
    if body_items.is_empty() {
        return Err(ParseError::LetMissingBody);
    }
    let mut clauses = chain_slices(group);
    for ci in &clauses {
        if !clause_is_binding(ci) {
            return Err(ParseError::MalformedBinding);
        }
    }
    clauses.push(body_items.to_vec());
    build_block(clauses)
}

/// Parse `recur (b0, b1, …) body`. Bindings are simultaneous and form an item table.
///
/// The table is sorted at parse to define the index space for sibling `ModItem`s.
/// An empty group returns `body` directly.
fn parse_recur_inner<'a>(group: &Seq<'a>, body_items: &[&Item<'a>]) -> Result<Expr, ParseError> {
    if body_items.is_empty() {
        return Err(ParseError::RecurMissingBody);
    }
    let syntax = parse_module(group)?;
    if !syntax.imports.is_empty() {
        return Err(ParseError::MisplacedImport);
    }
    if !syntax.iotas.is_empty() {
        return Err(ParseError::MisplacedConst);
    }
    if !syntax.locals.is_empty() {
        return Err(ParseError::MisplacedLocal);
    }
    if syntax.main.is_some() {
        return Err(ParseError::MisplacedReserved);
    }
    let mut bindings = syntax.items;
    let body = parse_segment(body_items)?;
    if bindings.is_empty() {
        return Ok(body);
    }
    bindings.sort_by(|(a, _), (b, _)| a.as_str().cmp(b.as_str()));
    Ok(Expr::Recur(Rc::new(ModuleData::from_bindings(
        bindings,
        Vec::new(),
        Box::new([]),
        Box::new([]),
        Box::new([]),
        Some(body),
        None,
    ))))
}

/// Parse a binding chain `<pattern> "=" <expr>`.
/// Separates on the first top-level `=`. Head and tail must be non-empty.
fn parse_binding<'a>(items: &[&Item<'a>]) -> Result<(Pattern, Expr), ParseError> {
    let mut eq = None;
    for (i, it) in items.iter().enumerate() {
        if matches!(it, Item::Punct("=")) {
            if eq.is_some() {
                return Err(ParseError::MalformedBinding);
            }
            eq = Some(i);
        }
    }
    let eq = eq.ok_or(ParseError::MalformedBinding)?;
    let (head, tail) = (&items[..eq], &items[eq + 1..]);
    if head.is_empty() || tail.is_empty() {
        return Err(ParseError::MalformedBinding);
    }
    if head.iter().any(|it| matches!(it, Item::Punct("|"))) {
        return Err(ParseError::LetOrUnparenthesized);
    }
    if let [it] = head {
        if is_bare_literal_header(it) {
            return Err(ParseError::BareLiteralHeader);
        }
    }
    let pat = parse_pattern(head)?;
    let value = parse_items(tail)?;
    Ok((pat, value))
}

/// Parse a single item as an atomic expression.
fn parse_aexpr<'a>(item: &Item<'a>) -> Result<Expr, ParseError> {
    match item {
        Item::Sym(s) => Ok(parse_sym(s)?),
        Item::Prefixed { sigil: '.', item } => parse_dot_symbol(item),
        Item::Brackets(_) => Err(ParseError::BareListLiteral),
        Item::Parens(seq) => parse_group(seq),
        Item::Str(s) => Ok(Expr::Str(decode_str(s)?)),
        Item::Braces(seq) => parse_block(seq),
        Item::Punct(".") => Err(ParseError::CombinatorDeferred),
        Item::Punct(_) => Err(ParseError::PunctAtAtom),
        Item::Comm(_) => Err(ParseError::EmptyChain),
        Item::Prefixed { sigil: '#', item } => match item.as_ref() {
            Item::Brackets(seq) => parse_list(seq),
            Item::Braces(seq) => parse_map(seq),
            _ => Err(ParseError::ReservedLiteralForm),
        },
        Item::Prefixed { .. } => Err(ParseError::UnexpectedBinder),
        Item::Run(members) => parse_run(members),
    }
}

/// Lower a run (glued atoms) to the expression its members form as one chain.
fn parse_run<'a>(members: &[Item<'a>]) -> Result<Expr, ParseError> {
    check_run_head(members)?;
    parse_items(
        members
            .iter()
            .map(|it| it as &Item<'_>)
            .collect::<Vec<_>>()
            .as_slice(),
    )
}

/// Reject `&`-headed runs and float-like runs (`3.14`).
fn check_run_head(members: &[Item<'_>]) -> Result<(), ParseError> {
    if matches!(&members[0], Item::Prefixed { sigil: '&', .. }) {
        return Err(ParseError::BinderRunGlued);
    }
    if let (
        Item::Sym(head),
        Some(Item::Prefixed {
            sigil: '.',
            item: seg,
        }),
    ) = (&members[0], members.get(1))
    {
        if parse_int(head).is_some() && is_dot_number(seg) {
            return Err(ParseError::FloatLiteralUnsupported);
        }
    }
    Ok(())
}

/// Check if a `.`-prefixed segment is a number (float tail).
fn is_dot_number(item: &Item<'_>) -> bool {
    match item {
        Item::Sym(s) => parse_int(s).is_some(),
        _ => false,
    }
}

/// Decode a Muon `<str>` literal into owned UTF-8 `Text`, combining surrogate pairs.
/// Unpaired surrogates cause [`ParseError::LoneSurrogate`].
fn decode_str(raw: &str) -> Result<Text, ParseError> {
    let b = raw.as_bytes();
    let mut out = String::with_capacity(raw.len());
    let mut i = 0;
    let mut chunk = 0;
    while i < b.len() {
        if b[i] != b'\\' {
            i += 1;
            continue;
        }
        out.push_str(&raw[chunk..i]);
        match b[i + 1] {
            b'"' => out.push('"'),
            b'\\' => out.push('\\'),
            b'/' => out.push('/'),
            b'n' => out.push('\n'),
            b't' => out.push('\t'),
            b'r' => out.push('\r'),
            b'b' => out.push('\u{8}'),
            b'f' => out.push('\u{c}'),
            b'u' => {
                let hi = hex4(&b[i + 2..i + 6]);
                i += 6;
                if (0xD800..=0xDBFF).contains(&hi) {
                    let lo = match (b.get(i), b.get(i + 1)) {
                        (Some(b'\\'), Some(b'u')) => hex4(&b[i + 2..i + 6]),
                        _ => return Err(ParseError::LoneSurrogate),
                    };
                    if !(0xDC00..=0xDFFF).contains(&lo) {
                        return Err(ParseError::LoneSurrogate);
                    }
                    let c = 0x1_0000 + ((hi - 0xD800) << 10) + (lo - 0xDC00);
                    out.push(char::from_u32(c).expect("combined surrogate pair"));
                    i += 6;
                } else if (0xDC00..=0xDFFF).contains(&hi) {
                    return Err(ParseError::LoneSurrogate);
                } else {
                    out.push(char::from_u32(hi).expect("non-surrogate BMP scalar"));
                }
                chunk = i;
                continue;
            }
            _ => unreachable!("Muon validated the <str> escape grammar"),
        }
        i += 2;
        chunk = i;
    }
    out.push_str(&raw[chunk..]);
    Ok(Text::from(out.as_str()))
}

/// Read four ASCII hex digits as a `u32`.
fn hex4(b: &[u8]) -> u32 {
    b.iter()
        .fold(0, |v, &c| v * 16 + (c as char).to_digit(16).unwrap())
}

/// Parse a `.`-prefixed item as a symbol.
fn parse_dot_symbol<'a>(item: &Item<'a>) -> Result<Expr, ParseError> {
    match item {
        Item::Sym(s) => Ok(Expr::Symbol(text(s))),
        _ => Err(ParseError::BadSymbol),
    }
}

/// Classify a `<sym>` as an integer literal, name, or error.
fn parse_sym(s: &str) -> Result<Expr, ParseError> {
    if s == "Self" {
        return Ok(Expr::Home {
            leaf: HomeLeaf::Module,
            depth: 0,
        });
    }
    if is_keyword(s) {
        return Err(ParseError::ReservedKeyword);
    }
    if s == "_" {
        Err(ParseError::DiscardReference)
    } else if let Some(n) = parse_int(s) {
        Ok(Expr::Int(n))
    } else if s.as_bytes()[0].is_ascii_digit() {
        Err(ParseError::MalformedNumber)
    } else if s.starts_with("__") {
        match Builtin::from_name(s) {
            Some(op) => Ok(Expr::Builtin(op)),
            None => Err(ParseError::UnknownReserved(text(s))),
        }
    } else {
        Ok(Expr::Name(text(s)))
    }
}

/// Parse an integer literal (decimal, hex, or binary) with `_` separators.
pub(crate) fn parse_int(s: &str) -> Option<BigInt> {
    let (neg, body) = match s.as_bytes().first()? {
        b'-' => (true, &s[1..]),
        b'+' => (false, &s[1..]),
        _ => (false, s),
    };
    let (radix, digits) =
        if let Some(h) = body.strip_prefix("0x").or_else(|| body.strip_prefix("0X")) {
            (16u32, h)
        } else if let Some(b) = body.strip_prefix("0b").or_else(|| body.strip_prefix("0B")) {
            (2, b)
        } else {
            (10, body)
        };
    let mut cleaned = String::new();
    let mut after_sep = true;
    for &c in digits.as_bytes() {
        if c == b'_' {
            if after_sep {
                return None;
            }
            after_sep = true;
        } else {
            cleaned.push(c as char);
            after_sep = false;
        }
    }
    if after_sep || cleaned.is_empty() {
        return None;
    }
    let mag = BigInt::parse_bytes(cleaned.as_bytes(), radix)?;
    Some(if neg { -mag } else { mag })
}

/// Parse an application spine, folding left.
/// `(…)` items are spread into multiple arguments.
fn parse_app_spine<'a>(items: &[&Item<'a>]) -> Result<Expr, ParseError> {
    let mut args: Vec<Expr> = Vec::new();
    for (i, it) in items.iter().enumerate() {
        if i == 0 {
            match *it {
                Item::Run(members) => {
                    check_run_head(members)?;
                    if is_self_head(members) {
                        args.push(Expr::Home {
                            leaf: HomeLeaf::New,
                            depth: 0,
                        });
                        for m in members[1..].iter() {
                            expand_arg(m, &mut args)?;
                        }
                    } else {
                        for m in members.iter() {
                            expand_arg(m, &mut args)?;
                        }
                    }
                }
                Item::Prefixed { sigil: '#', item }
                    if matches!(item.as_ref(), Item::Sym("Self")) =>
                {
                    args.push(Expr::Home {
                        leaf: HomeLeaf::New,
                        depth: 0,
                    });
                }
                _ => expand_arg(it, &mut args)?,
            }
        } else {
            expand_arg(it, &mut args)?;
        }
    }
    if matches!(
        args.as_slice(),
        [Expr::Home {
            leaf: HomeLeaf::New,
            ..
        }]
    ) {
        return Err(ParseError::ReservedLiteralForm);
    }
    Ok(fold_spine(args))
}

/// Fold a non-empty argument list: lone element is returned directly, else a flat `App`.
fn fold_spine(args: Vec<Expr>) -> Expr {
    if args.len() == 1 {
        args.into_iter().next().unwrap()
    } else {
        app(args)
    }
}

/// Check if a run is the glued `#Self(…)` construction.
fn is_self_head(members: &[Item<'_>]) -> bool {
    matches!(
        members.first(),
        Some(Item::Prefixed { sigil: '#', item })
            if matches!(item.as_ref(), Item::Sym("Self"))
    )
}

/// Expand one chain item into argument expressions. `(…)` groups spread;
/// other items are single atoms.
fn expand_arg<'a>(item: &'a Item<'a>, out: &mut Vec<Expr>) -> Result<(), ParseError> {
    match item {
        Item::Parens(seq) => expand_group_args(seq, out),
        Item::Prefixed { sigil: '.', item }
            if matches!(item.as_ref(), Item::Sym("Self")) && !out.is_empty() =>
        {
            let acc = fold_spine(core::mem::take(out));
            out.push(Expr::App(Box::new([
                Expr::Home {
                    leaf: HomeLeaf::Value,
                    depth: 0,
                },
                acc,
            ])));
            Ok(())
        }
        _ => {
            out.push(parse_aexpr(item)?);
            Ok(())
        }
    }
}

/// Expand `(…)` group chains as arguments (one chain $\to$ one argument).
/// Empty groups feed the unit value `()`.
fn expand_group_args<'a>(seq: &Seq<'a>, out: &mut Vec<Expr>) -> Result<(), ParseError> {
    let mut any = false;
    for items in chain_slices(seq) {
        out.push(parse_items(&items)?);
        any = true;
    }
    if !any {
        out.push(Expr::Unit);
    }
    Ok(())
}

/// Parse a `(…)` group as a standalone atom.
fn parse_group<'a>(seq: &Seq<'a>) -> Result<Expr, ParseError> {
    let mut args: Vec<Expr> = Vec::new();
    expand_group_args(seq, &mut args)?;
    Ok(fold_spine(args))
}

/// Parse a `[…]` list into a runtime list literal of *any* arity: `[]` (the
/// empty list, not unit), `[e]` (a genuine 1-list, not collapsed), `[e0, e1, …]`.
/// Each non-comment chain is one element expression.
fn parse_list<'a>(seq: &Seq<'a>) -> Result<Expr, ParseError> {
    let mut elems: Vec<Expr> = Vec::new();
    for items in chain_slices(seq) {
        elems.push(parse_items(&items)?);
    }
    Ok(Expr::List(elems))
}

/// Parse a `{…}` brace group as a **block expression** (syntax v1 step 6): a
/// sequence of clauses whose value is the last clause's. A block lowers onto the
/// same nested-abstraction chain a `let` group produces — `{ a = va, e }` is
/// `let (a = va) e`, i.e. `(&a e) va` — so it adds no evaluator node, and a
/// block *is* a scope because each binding becomes a lambda parameter that the
/// following clauses (and nothing outside) can see.
///
/// - The empty block `{}` is the unit value `()`, and `{ e }` is `e` — the
///   degenerate-case identities.
/// - Each **non-final** clause is a binding (`<pat> = <expr>`, a top-level `=`,
///   bound over the rest) or a bare expression (evaluated for its effect, its
///   value discarded — lowered to a `_ =` binding, today's `_ = io.print(…)`).
/// - The **final** clause is the block's value and must be an expression; a
///   trailing binding is [`BlockTrailingBinding`](ParseError::BlockTrailingBinding).
///
/// A `:`-clause (a stale bare-map entry) has no reading in a block and is refused
/// with the `#{…}` nudge, as it is in every brace position. Clauses are the
/// `<seq>`'s joined non-comment chains, so a block may be laid out multi-line
/// with blank lines, comments, and the chain-continuation joins.
fn parse_block<'a>(seq: &Seq<'a>) -> Result<Expr, ParseError> {
    // A `:`-clause is the one shape a block shares with the old bare map; keep
    // the pointed error rather than letting it fall through as a bad expression.
    if braces_contain_colon(seq) {
        return Err(ParseError::BareMapLiteral);
    }
    build_block(chain_slices(seq))
}

/// Build an [`Expr::Block`] from a block's (already joined, comment-free) clause
/// chains — shared by the `{…}` block and by `let (…) e` (its group's binding
/// chains plus its body as the final clause). Each clause becomes a
/// [`Clause::Bind`] (a chain with a top-level `=`) or a [`Clause::Do`] (a bare
/// expression). The degenerate blocks collapse rather than build a node: an empty
/// clause list is the unit value `()`, and a single expression clause is that
/// expression (`{ e }` is `e`). A trailing binding is rejected — a block's value
/// is its last clause's, and a binding leaves none (and its name would not
/// escape) — so the final clause is always a `Do`.
fn build_block<'a>(clauses: Vec<Vec<&Item<'a>>>) -> Result<Expr, ParseError> {
    let Some((last, leading)) = clauses.split_last() else {
        return Ok(Expr::Unit); // `{}` / `let () e` with no body chain — unit
    };
    if clause_is_binding(last) {
        return Err(ParseError::BlockTrailingBinding);
    }
    if leading.is_empty() {
        return parse_items(last); // `{ e }` is `e`
    }
    let mut built: Vec<(Option<Pattern>, Expr)> = Vec::with_capacity(leading.len() + 1);
    for ci in leading {
        let clause = if clause_is_binding(ci) {
            let (pat, value) = parse_binding(ci)?;
            (Some(pat), value)
        } else {
            (None, parse_items(ci)?)
        };
        built.push(clause);
    }
    built.push((None, parse_items(last)?));
    Ok(Expr::Block(built.into_boxed_slice()))
}

/// Whether a block clause is a **binding** — it carries a top-level `=` punct.
/// A nested `=` lives inside a `(…)`/`[…]`/`{…}` item, never as a top-level
/// `Item::Punct`, so this is exactly the `<binding>` vs `<chain>` split the
/// `let` group makes (and [`parse_binding`] then splits at the first `=`).
fn clause_is_binding(items: &[&Item<'_>]) -> bool {
    items.iter().any(|it| matches!(it, Item::Punct("=")))
}

/// Parse a `{…}` block into a map literal: each non-comment chain of the `<seq>`
/// is one entry (see `parse_entry`); comment-only chains are skipped (so a map may
/// be laid out multi-line with blank lines and comments). Entry order is source
/// order — evaluation re-sorts by the value order.
fn parse_map<'a>(seq: &Seq<'a>) -> Result<Expr, ParseError> {
    let mut entries: Vec<(Expr, Expr)> = Vec::new();
    for items in chain_slices(seq) {
        entries.push(parse_entry(&items)?);
    }
    Ok(Expr::Map(entries))
}

/// Parse one map entry `<key> ":" <value>`. The `:` is a single `<punct>` item at
/// position 1; the key is the single head item (`parse_key`) and the value is the
/// rest of the chain parsed as an `<expr>`. An *empty* value tail is sugar for the
/// unit value `()` (so `{ .foo: }` == `{ .foo: () }`).
fn parse_entry<'a>(items: &[&Item<'a>]) -> Result<(Expr, Expr), ParseError> {
    if items.len() < 2 || !matches!(items[1], Item::Punct(":")) {
        return Err(ParseError::MalformedMapKey);
    }
    let key = parse_key(items[0])?;
    let value_items = &items[2..];
    let value = if value_items.is_empty() {
        Expr::Unit // empty rest → the unit value ()
    } else {
        parse_items(value_items)?
    };
    Ok((key, value))
}

/// Parse a map-entry key item. A bare *non-digit* atom key is the **symbol** of
/// the same spelling — `one` == `.one` — mirroring `.foo` exactly; a key is just
/// a token. A **digit-leading** bare key (`0`, `5`) is rejected to avoid the
/// number/symbol confusion: write `.0` for the symbol or `(0)` for the integer.
/// Wrap a key as a `(…)` **computed** key to evaluate it: `(one)` is the *value*
/// of variable `one`, `(0)` the integer `0`; an *empty* `()` is the unit key.
/// The remaining forms are a `.`-prefixed symbol (`.one`) and a `#[…]` / `#{…}`
/// literal key (`#[]` the empty-list key). A bare `[…]` / `{…}` key routes to the
/// same place only to be refused with its `#`-spelling nudge (`BareListLiteral` /
/// `BareMapLiteral`); anything else is a `MalformedMapKey`.
fn parse_key<'a>(item: &Item<'a>) -> Result<Expr, ParseError> {
    match item {
        // A bare non-digit `<sym>` key is the symbol of that spelling, read
        // exactly as `.<sym>` would be. A digit-leading key is rejected — write
        // `.5` (the symbol) or `(5)` (the computed integer key) to disambiguate.
        Item::Sym(s) if s.as_bytes()[0].is_ascii_digit() => Err(ParseError::MalformedMapKey),
        Item::Sym(s) => Ok(Expr::Symbol(text(s))),
        // A bare `{…}` in key position is a block expression at the atom layer,
        // which has no reading as a key — refuse it with the `#{…}` nudge rather
        // than silently keying on a block value (write `#{…}` for a map key).
        Item::Braces(_) => Err(ParseError::BareMapLiteral),
        // `.sym` symbol key, `(…)` computed key (empty `()` the unit key), `"…"`
        // string key, and the explicit `#[…]` / `#{…}` literal keys — each reads
        // exactly as the same item would at atom position. A bare `[…]` routes
        // here too, only to be refused with its `#[…]`-spelling nudge.
        Item::Prefixed { sigil: '.', .. }
        | Item::Prefixed { sigil: '#', .. }
        | Item::Brackets(_)
        | Item::Parens(_)
        | Item::Str(_) => parse_aexpr(item),
        // A **path** key (`{ Mod.k: v }`) denotes a concrete value by reference,
        // so it is a lookup key alongside the `.sym` / bare-sym forms (§E).
        Item::Run(members) => parse_path(members).map_err(|_| ParseError::MalformedMapKey),
        _ => Err(ParseError::MalformedMapKey),
    }
}

// ===========================================================================
// patterns
// ===========================================================================

/// `&<pattern> body` — the one binding form every abstraction (and `let`, and a
/// `__match` clause) is built from. Greedily **collects** into one multi-parameter
/// [`Lambda`]: when `body` is *directly* another abstraction (a run of `&p0 &p1 …`,
/// or a curried binder group), `pat` is prepended to its head so the whole run
/// shares one code node with a known arity. Collection stops at the first
/// non-abstraction body (a `&` nested inside an application does not extend the
/// arity) and at 255 parameters — a head that would exceed the `applied: u8`
/// counter starts a fresh nested `Lambda` instead of overflowing.
fn abs(pat: Pattern, body: Expr) -> Expr {
    match body {
        Expr::Abs(lam) if lam.head.len() < 255 => {
            // Prepend `pat` to the (freshly built, so uniquely owned) inner head.
            let lam = Rc::try_unwrap(lam).unwrap_or_else(|rc| (*rc).clone());
            let mut head = Vec::with_capacity(lam.head.len() + 1);
            head.push(pat);
            head.extend(Vec::from(lam.head));
            Expr::Abs(Rc::new(Lambda {
                head: head.into_boxed_slice(),
                body: lam.body,
                // Free variables are a resolution artifact: the parser leaves the
                // capture plan unresolved and `resolve.rs` fills it in.
                captures: Captures::Unresolved,
            }))
        }
        _ => Expr::Abs(Rc::new(Lambda {
            head: Box::new([pat]),
            body,
            captures: Captures::Unresolved,
        })),
    }
}

/// Build an application node from a flat call spine `[callee, arg0, …]` (≥ 2
/// elements). A single-element `items` is *not* an application — the caller
/// returns that element directly.
fn app(items: Vec<Expr>) -> Expr {
    debug_assert!(
        items.len() >= 2,
        "an application has a callee and ≥1 argument"
    );
    Expr::App(items.into_boxed_slice())
}

/// Apply `f` to one more `arg`, extending `f`'s call spine when it already is one
/// so `g x &y …` and `x |> f a` stay single flattened `App` nodes (a partial
/// applied to a trailing abstraction / pipe operand). Currying makes this
/// equivalent to a fresh binary application, and it re-renders identically.
fn append_arg(f: Expr, arg: Expr) -> Expr {
    match f {
        Expr::App(items) => {
            let mut v = Vec::from(items);
            v.push(arg);
            Expr::App(v.into_boxed_slice())
        }
        _ => Expr::App(Box::new([f, arg])),
    }
}

/// Whether `item` is a bare **matching literal** — a number, a `.`-symbol, or a
/// string — used where a whole `&`-header or `let` LHS is expected. These are
/// equality patterns, not binders, so a bare one reads as a stray value or an
/// intended binding; Elly requires the wrap (`&(42)`, `&(.foo)`, `&("s")`; see
/// `BareLiteralHeader`). Nested in `[…]`/`{…}`/`(…)`/an or-pattern they are fine.
fn is_bare_literal_header(item: &Item<'_>) -> bool {
    match item {
        Item::Sym(s) => parse_int(s).is_some(),
        Item::Prefixed { sigil: '.', .. } => true,
        Item::Str(_) => true,
        _ => false,
    }
}

/// Build the abstraction(s) an `&`-header `&<inner>` introduces over `body`. A
/// `(…)` inner is a **binder group** whose commas curry (`&(a, b)` → two params);
/// any other inner is a single-parameter pattern.
fn build_binder<'a>(inner: &Item<'a>, body: Expr) -> Result<Expr, ParseError> {
    match inner {
        Item::Parens(seq) => build_group(seq, body),
        // A bare matching literal (number `&42`, symbol `&.foo`, string `&"s"`) as
        // the whole header must be parenthesized: `&(42)`, `&(.foo)`, `&("s")` (see
        // `BareLiteralHeader`). Nested literals reach `parse_atom_item` unaffected.
        it if is_bare_literal_header(it) => Err(ParseError::BareLiteralHeader),
        other => {
            let pat = parse_pattern(&[other])?;
            Ok(abs(pat, body))
        }
    }
}

/// Build a curried binder group `&(p0, p1, …)`: each non-comment chain is one
/// parameter pattern, curried left-to-right (leftmost outermost). An empty group
/// `&()` is the nullary marker — one param, the unit pattern that matches `()`.
fn build_group<'a>(seq: &Seq<'a>, body: Expr) -> Result<Expr, ParseError> {
    let params = chain_slices(seq);
    if params.is_empty() {
        // `&()` → the unit pattern: assert the argument is unit `()`.
        return Ok(abs(Pattern::Unit, body));
    }
    let mut acc = body;
    for chain in params.iter().rev() {
        let pat = parse_pattern(chain)?;
        acc = abs(pat, acc);
    }
    Ok(acc)
}

/// Parse `case <subject>? { arms }`. Subjectless cases are lowered to
/// `&__arg (case __arg { ... })`.
fn parse_case<'a>(items: &[&Item<'a>]) -> Result<Expr, ParseError> {
    let mut rest: Vec<&Item<'a>> = Vec::new();
    if let Item::Run(members) = items[0] {
        for m in &members[1..] {
            rest.push(m);
        }
    }
    rest.extend_from_slice(&items[1..]);
    let (last, subject_items) = rest.split_last().ok_or(ParseError::CaseMissingArms)?;
    let arms_seq = match last {
        Item::Braces(seq) => seq,
        _ => return Err(ParseError::CaseMissingArms),
    };
    let cases = parse_arms(arms_seq)?;
    match subject_items {
        [] => {
            let subject = Rc::new(Expr::Name(text("__arg")));
            Ok(abs(
                Pattern::Bind(text("__arg")),
                Expr::Case { subject, cases },
            ))
        }
        [subj] => Ok(Expr::Case {
            subject: Rc::new(parse_aexpr(subj)?),
            cases,
        }),
        _ => Err(ParseError::CaseSubjectExtra),
    }
}

/// Parse `case` arms from a block, one per non-comment chain.
fn parse_arms<'a>(seq: &Seq<'a>) -> Result<Box<[(Pattern, Expr)]>, ParseError> {
    let chains = chain_slices(seq);
    if chains.is_empty() {
        return Err(ParseError::CaseMissingArms);
    }
    let mut arms = Vec::with_capacity(chains.len());
    for chain in &chains {
        arms.push(parse_arm(chain)?);
    }
    Ok(arms.into_boxed_slice())
}

/// Parse an arm: `& <pattern> (when (<cond>))* <body>`.
fn parse_arm<'a>(items: &[&Item<'a>]) -> Result<(Pattern, Expr), ParseError> {
    let inner = match items.first() {
        Some(Item::Prefixed { sigil: '&', item }) => item.as_ref(),
        _ => return Err(ParseError::ArmNotBinder),
    };
    if is_bare_literal_header(inner) {
        return Err(ParseError::BareLiteralHeader);
    }
    let base = parse_pattern(&[inner])?;
    let (pat, rest) = peel_when(base, &items[1..])?;
    if rest.is_empty() {
        return Err(ParseError::ArmMissingBody);
    }
    let body = parse_items(rest)?;
    Ok((pat, body))
}

/// Fold `when (<cond>)` guards onto a pattern.
fn peel_when<'a, 'b>(
    mut base: Pattern,
    mut items: &'b [&'b Item<'a>],
) -> Result<(Pattern, &'b [&'b Item<'a>]), ParseError> {
    while !items.is_empty() && is_when_kw(items[0]) {
        let (group, next): (&Seq<'a>, &[&Item<'a>]) = match items[0] {
            Item::Run(members) if members.len() == 2 => match &members[1] {
                Item::Parens(seq) => (seq, &items[1..]),
                _ => return Err(ParseError::WhenMissingCond),
            },
            Item::Run(_) => return Err(ParseError::WhenMissingCond),
            _ => match items.get(1) {
                Some(Item::Parens(seq)) => (seq, &items[2..]),
                _ => return Err(ParseError::WhenMissingCond),
            },
        };
        let cond = parse_when_cond(group)?;
        base = Pattern::When {
            inner: Box::new(base),
            when: cond,
        };
        items = next;
    }
    Ok((base, items))
}

/// Check if an item is the `when` guard keyword.
fn is_when_kw(item: &Item) -> bool {
    head_keyword(item) == Some("when")
}

/// Parse a `when` condition (plain or pattern guard).
fn parse_when_cond<'a>(seq: &Seq<'a>) -> Result<(Option<Box<Pattern>>, Expr), ParseError> {
    let chain = single_chain(seq).ok_or(ParseError::WhenMissingCond)?;
    if chain.is_empty() {
        return Err(ParseError::WhenMissingCond);
    }
    if chain.iter().any(|it| matches!(it, Item::Punct("="))) {
        let (pat, expr) = parse_binding(&chain)?;
        Ok((Some(Box::new(pat)), expr))
    } else {
        Ok((None, parse_items(&chain)?))
    }
}

/// Returns non-comment chains of a `<seq>` with [chain-joining](join_chains) applied.
fn chain_slices<'a, 'b>(seq: &'b Seq<'a>) -> Vec<Vec<&'b Item<'a>>> {
    let chains = seq
        .0
        .iter()
        .filter(|c| !is_comment_only(c))
        .map(|c| {
            c.0.iter()
                .filter(|it| !matches!(it, Item::Comm(_)))
                .collect()
        })
        .collect();
    join_chains(chains)
}

/// Returns true if a `<braces>` seq contains a chain whose second non-comment item is `:`.
/// Used by [`parse_block`] to reject bare-map spellings.
fn braces_contain_colon(seq: &Seq<'_>) -> bool {
    for chain in seq.0.iter().filter(|c| !is_comment_only(c)) {
        let items: Vec<&Item<'_>> = chain
            .0
            .iter()
            .filter(|it| !matches!(it, Item::Comm(_)))
            .collect();
        if items.len() >= 2 && matches!(items[1], Item::Punct(":")) {
            return true;
        }
    }
    false
}

/// Joins adjacent chains if they form a single continued expression.
/// A chain joins if the predecessor ends with a continuation (e.g., `&`, `=`, `|>`, `when`)
/// or if the current chain starts with one (e.g., `|>`, `elif`, `else`, `catch`).
fn join_chains<'a, 'b>(chains: Vec<Vec<&'b Item<'a>>>) -> Vec<Vec<&'b Item<'a>>> {
    let mut out: Vec<Vec<&'b Item<'a>>> = Vec::with_capacity(chains.len());
    for chain in chains {
        let join = matches!(out.last(), Some(prev) if trailing_join(prev) || leading_join(&chain));
        if join {
            out.last_mut().unwrap().extend(chain);
        } else {
            out.push(chain);
        }
    }
    out
}

/// Whether a chain ends with a trailing continuation.
fn trailing_join(chain: &[&Item]) -> bool {
    match chain.last() {
        Some(Item::Prefixed { sigil: '&', .. }) => true,
        Some(Item::Punct("=")) | Some(Item::Punct("|>")) => true,
        _ => {
            let n = chain.len();
            n >= 2
                && matches!(chain[n - 2], Item::Sym("when"))
                && matches!(chain[n - 1], Item::Parens(_))
        }
    }
}

/// Whether a chain opens with a leading continuation.
fn leading_join(chain: &[&Item]) -> bool {
    match chain.first() {
        Some(Item::Punct("|>")) => true,
        Some(first) => matches!(head_keyword(first), Some("elif" | "else" | "catch")),
        None => false,
    }
}

/// Returns the single non-comment chain of a `<seq>`, if it contains exactly one.
fn single_chain<'a, 'b>(seq: &'b Seq<'a>) -> Option<Vec<&'b Item<'a>>> {
    let mut chains = chain_slices(seq).into_iter();
    let first = chains.next()?;
    if chains.next().is_some() {
        return None;
    }
    Some(first)
}

/// Parse a pattern from a chain of items. Splits on `|` (or-pattern),
/// then `=` (equality / at-pattern), otherwise defers to `as` / atom levels.
fn parse_pattern<'a>(items: &[&Item<'a>]) -> Result<Pattern, ParseError> {
    if items.is_empty() {
        return Err(ParseError::BadPattern);
    }
    if let Some(idx) = items.iter().position(|it| matches!(it, Item::Punct("|"))) {
        let left = parse_pattern(&items[..idx])?;
        let right = parse_pattern(&items[idx + 1..])?;
        return Ok(Pattern::Or(Box::new(left), Box::new(right)));
    }
    match items[0] {
        Item::Punct("<") => return Ok(Pattern::Less(parse_comparand(&items[1..])?)),
        Item::Punct(">") => return Ok(Pattern::Greater(parse_comparand(&items[1..])?)),
        _ => {}
    }
    if let Some(idx) = items.iter().position(|it| matches!(it, Item::Punct("="))) {
        if idx == 0 {
            return Ok(Pattern::Equal(parse_comparand(&items[1..])?));
        }
        let name = at_name(&items[..idx])?;
        let inner = parse_pattern(&items[idx + 1..])?;
        return Ok(Pattern::At(name, Box::new(inner)));
    }
    parse_as(items)
}

/// Parse the RHS of an `=` / `<` / `>` comparand: exactly one atom.
/// A pattern is a closed grammar; comparands never recurse into `parse_items`.
fn parse_comparand<'a>(items: &[&Item<'a>]) -> Result<Expr, ParseError> {
    match items {
        [it] => match it {
            Item::Sym(s) => parse_sym(s),
            Item::Prefixed { sigil: '.', item } => parse_dot_symbol(item),
            Item::Str(s) => Ok(Expr::Str(decode_str(s)?)),
            Item::Run(members) => parse_path(members),
            _ => Err(ParseError::ComparandNotAtom),
        },
        _ => Err(ParseError::ComparandNotAtom),
    }
}

/// The bound name of an at-pattern's LHS: one plain name.
fn at_name<'a>(items: &[&Item<'a>]) -> Result<Text, ParseError> {
    plain_name(items, ParseError::BadPattern)
}

/// Parse the narrowing level: `Self <pat>`, `(as <Proto>) <pat>`, `<pat> as <Proto>`, or a bare atom.
fn parse_as<'a>(items: &[&Item<'a>]) -> Result<Pattern, ParseError> {
    if let Item::Sym("Self") = items[0] {
        if items.len() < 2 {
            return Err(ParseError::BadPattern);
        }
        let inner = parse_pattern(&items[1..])?;
        return Ok(Pattern::Unwrap {
            depth: 0,
            inner: Box::new(inner),
        });
    }
    if let Item::Parens(seq) = items[0] {
        if let Some(chain) = single_chain(seq) {
            if !chain.is_empty() && matches!(chain[0], Item::Sym("as")) {
                let proto = parse_proto_ref(&chain[1..])?;
                let inner = parse_pattern(&items[1..])?;
                return Ok(Pattern::Type(proto, Box::new(inner)));
            }
        }
    }
    if let Some(idx) = items.iter().position(|it| matches!(it, Item::Sym("as"))) {
        let proto = parse_proto_ref(&items[idx + 1..])?;
        let inner = parse_atom(&items[..idx])?;
        return Ok(Pattern::Type(proto, Box::new(inner)));
    }
    parse_atom(items)
}

/// Parse a prototype for `as <Proto>`: exactly one name (a module reference).
fn parse_proto_ref(items: &[&Item<'_>]) -> Result<ProtoRef, ParseError> {
    let e = match items {
        [Item::Sym(s)] => parse_sym(s)?,
        [Item::Run(members)] => parse_path(members)?,
        _ => return Err(ParseError::UnknownType),
    };
    match e {
        e @ (Expr::Name(_) | Expr::Builtin(_) | Expr::Home { .. } | Expr::App(_)) => {
            Ok(ProtoRef::Ref(e))
        }
        _ => Err(ParseError::UnknownType),
    }
}

/// Parse a path: a run starting with an identifier followed by `.`-prefixed segments.
/// Lowers to a left fold of the head applied to symbol literals.
fn parse_path<'a>(members: &[Item<'a>]) -> Result<Expr, ParseError> {
    if members.len() < 2 {
        return Err(ParseError::ComparandNotAtom);
    }
    let head = match &members[0] {
        Item::Sym(s) => parse_sym(s)?,
        _ => return Err(ParseError::ComparandNotAtom),
    };
    for m in &members[1..] {
        if !matches!(m, Item::Prefixed { sigil: '.', .. }) {
            return Err(ParseError::ComparandNotAtom);
        }
    }
    let mut acc = head;
    for m in &members[1..] {
        if let Item::Prefixed { sigil: '.', item } = m {
            acc = Expr::App(Box::new([acc, parse_dot_symbol(item)?]));
        }
    }
    Ok(acc)
}

/// Parse an atomic pattern: a single item or a `(…)` grouping of one pattern.
fn parse_atom<'a>(items: &[&Item<'a>]) -> Result<Pattern, ParseError> {
    match items {
        [it] => parse_atom_item(it),
        _ => Err(ParseError::BadPattern),
    }
}

/// Parse a single atomic-pattern item.
fn parse_atom_item<'a>(item: &Item<'a>) -> Result<Pattern, ParseError> {
    match item {
        Item::Sym("_") => Ok(Pattern::Discard),
        Item::Sym(s) if is_keyword(s) => Err(ParseError::ReservedKeyword),
        Item::Sym(s) if s.starts_with("__") => Err(ParseError::ReservedName),
        Item::Sym(s) => match parse_int(s) {
            Some(n) => Ok(Pattern::Equal(Expr::Int(n))),
            None if s.as_bytes()[0].is_ascii_digit() => Err(ParseError::MalformedNumber),
            None => Ok(Pattern::Bind(text(s))),
        },
        Item::Prefixed { sigil: '.', item } => Ok(Pattern::Equal(parse_dot_symbol(item)?)),
        Item::Str(s) => Ok(Pattern::Equal(Expr::Str(decode_str(s)?))),
        Item::Brackets(_) => Err(ParseError::BareListLiteral),
        Item::Parens(seq) => match single_chain(seq) {
            Some(chain) if !chain.is_empty() => parse_pattern(&chain),
            _ => Err(ParseError::BadPattern),
        },
        Item::Braces(_) => Err(ParseError::BareMapLiteral),
        Item::Prefixed { sigil: '#', item } => match item.as_ref() {
            Item::Brackets(seq) => parse_list_pattern(seq),
            Item::Braces(seq) => parse_map_pattern(seq),
            _ => Err(ParseError::ReservedLiteralForm),
        },
        _ => Err(ParseError::BadPattern),
    }
}

/// Parse a `{ k0: p0, … }` map pattern.
/// Keys are patterns; literals and equality forms are lookups, others are captures.
fn parse_map_pattern<'a>(seq: &Seq<'a>) -> Result<Pattern, ParseError> {
    let chains = chain_slices(seq);
    let n = chains.len();
    let mut entries: Vec<(MapKey, Pattern)> = Vec::new();
    let mut rest: Option<Box<Pattern>> = None;
    for (i, chain) in chains.iter().enumerate() {
        if let Some(r) = as_rest(chain) {
            if i != n - 1 {
                return Err(ParseError::BadPattern);
            }
            rest = Some(r);
        } else {
            let colon = chain
                .iter()
                .position(|it| matches!(it, Item::Punct(":")))
                .ok_or(ParseError::MalformedMapKey)?;
            let val_items = &chain[colon + 1..];
            if colon == 0 || val_items.is_empty() {
                return Err(ParseError::MalformedMapKey);
            }
            let key_items = &chain[..colon];
            let bare_sym = match key_items {
                [Item::Sym(s)] => Some(*s),
                _ => None,
            };
            let key = if let Some(s) = bare_sym {
                if s.as_bytes()[0].is_ascii_digit() {
                    return Err(ParseError::MalformedMapKey);
                }
                MapKey::Lookup(Expr::Symbol(text(s)))
            } else if let [Item::Run(members)] = key_items {
                MapKey::Lookup(parse_path(members)?)
            } else {
                match parse_pattern(key_items)? {
                    Pattern::Equal(expr) => MapKey::Lookup(expr),
                    kpat => MapKey::Capture(Box::new(kpat)),
                }
            };
            let valpat = parse_pattern(val_items)?;
            entries.push((key, valpat));
        }
    }
    Ok(Pattern::Map { entries, rest })
}

/// Parse a `[…]` list pattern with an optional trailing rest.
fn parse_list_pattern<'a>(seq: &Seq<'a>) -> Result<Pattern, ParseError> {
    let chains = chain_slices(seq);
    let n = chains.len();
    let mut elems: Vec<Pattern> = Vec::new();
    let mut rest: Option<Box<Pattern>> = None;
    for (i, chain) in chains.iter().enumerate() {
        if let Some(r) = as_rest(chain) {
            if i != n - 1 {
                return Err(ParseError::BadPattern);
            }
            rest = Some(r);
        } else {
            elems.push(parse_pattern(chain)?);
        }
    }
    Ok(Pattern::List { elems, rest })
}

/// Recognize a trailing-rest element chain (`...rest` or `...`).
fn as_rest<'a>(chain: &[&Item<'a>]) -> Option<Box<Pattern>> {
    if chain.len() != 1 {
        return None;
    }
    if let Item::Prefixed {
        sigil: '.',
        item: a,
    } = chain[0]
    {
        if let Item::Prefixed {
            sigil: '.',
            item: b,
        } = a.as_ref()
        {
            match b.as_ref() {
                Item::Prefixed {
                    sigil: '.',
                    item: c,
                } => {
                    if let Item::Sym(name) = c.as_ref() {
                        return Some(Box::new(Pattern::Bind(text(name))));
                    }
                }
                Item::Punct(".") => return Some(Box::new(Pattern::Discard)),
                _ => {}
            }
        }
    }
    None
}

/// Whether a chain holds only comments.
fn is_comment_only(chain: &Chain) -> bool {
    chain.0.iter().all(|it| matches!(it, Item::Comm(_)))
}

/// Whether `s` is an Elly keyword.
fn is_keyword(s: &str) -> bool {
    matches!(
        s,
        "Self"
            | "let"
            | "recur"
            | "import"
            | "const"
            | "local"
            | "with"
            | "as"
            | "when"
            | "match"
            | "case"
            | "of"
            | "if"
            | "elif"
            | "else"
            | "catch"
    )
}

/// Whether `name` can be bound and referenced from source as a plain name.
pub fn is_bindable_name(name: &str) -> bool {
    muon::is_sym(name)
        && !is_keyword(name)
        && !name.starts_with("__")
        && name != "_"
        && !reads_as_number(name)
}

/// Whether this item is a chain split point (e.g., `&`-binder or `let`/`recur`/`case`).
fn is_split_point(item: &Item) -> bool {
    is_binder(item)
        || matches!(
            head_keyword(item),
            Some("let") | Some("recur") | Some("case")
        )
}

/// Whether this item is a `&`-prefixed binder.
fn is_binder(item: &Item) -> bool {
    matches!(item, Item::Prefixed { sigil: '&', .. })
}

/// The keyword head of an item, if any (bare keyword or head of a keyword-headed run).
fn head_keyword<'a>(item: &Item<'a>) -> Option<&'a str> {
    match item {
        Item::Sym(s) if is_keyword(s) => Some(s),
        Item::Run(members) => match members.first() {
            Some(Item::Sym(s)) if is_keyword(s) => Some(s),
            _ => None,
        },
        _ => None,
    }
}