From 3e2d801cd1b63894dd9899ab00f82eba427d2fb0 Mon Sep 17 00:00:00 2001
From: Peter Duchovni <caufeminecraft+github@gmail.com>
Date: Fri, 16 May 2025 17:21:03 +1000
Subject: [PATCH 1/4] Add Format::Sequence (vec codegen backend), Expr::Append

---
 doodle-formats/src/format/png.rs |   2 +-
 generated/gencode.rs             |  73 +++++------
 src/codegen/mod.rs               |  76 ++++++++++-
 src/codegen/rust_ast/mod.rs      | 216 ++++++++++++++++++++++++-------
 src/codegen/rust_ast/rebind.rs   |  34 +++--
 src/codegen/rust_ast/resolve.rs  |  85 ++++++++----
 src/codegen/typed_decoder.rs     |  17 ++-
 src/codegen/typed_format.rs      |  22 +++-
 src/decoder.rs                   |  58 ++++++---
 src/decoder/seq_kind.rs          |  31 +++++
 src/helper.rs                    |  12 +-
 src/lib.rs                       |  98 +++++++++-----
 src/loc_decoder.rs               |  43 ++++--
 src/output/flat.rs               |  12 +-
 src/output/tree.rs               | 106 ++++++++++++++-
 src/precedence.rs                |   3 +
 src/prelude.rs                   |  11 ++
 src/typecheck.rs                 |  23 ++++
 18 files changed, 725 insertions(+), 197 deletions(-)

diff --git a/doodle-formats/src/format/png.rs b/doodle-formats/src/format/png.rs
index 80ba7e8b..c578b375 100644
--- a/doodle-formats/src/format/png.rs
+++ b/doodle-formats/src/format/png.rs
@@ -466,7 +466,7 @@ pub fn main(
     module.define_format(
         "png.main",
         record_auto([
-            ("__signature", is_bytes(PNG_SIGNATURE)),
+            ("signature", byte_seq(PNG_SIGNATURE)),
             ("ihdr", ihdr.call()),
             ("chunks", repeat(png_chunk.call_args(vec![var("ihdr")]))),
             (
diff --git a/generated/gencode.rs b/generated/gencode.rs
index 4e22e13c..8b4ce61e 100644
--- a/generated/gencode.rs
+++ b/generated/gencode.rs
@@ -4242,9 +4242,10 @@ tag: (u8, u8, u8, u8),
 crc: u32
 }
 
-/// expected size: 184
+/// expected size: 208
 #[derive(Debug, Clone)]
 pub struct png_main {
+signature: Vec<u8>,
 ihdr: png_ihdr,
 chunks: Vec<png_chunk>,
 idat: zlib_main,
@@ -4951,72 +4952,72 @@ PResult::Ok(mpeg4_main { atoms })
 }
 
 fn Decoder_png_main<>(_input: &mut Parser<'_>) -> Result<png_main, ParseError> {
-{
-let field0 = ((|| {
+let signature = {
+let _seq0 = {
 let b = _input.read_byte()?;
-PResult::Ok(if b == 137 {
+if b == 137 {
 b
 } else {
 return Err(ParseError::ExcludedBranch(8253205784254894771u64));
-})
-})())?;
-let field1 = ((|| {
+}
+};
+let _seq1 = {
 let b = _input.read_byte()?;
-PResult::Ok(if b == 80 {
+if b == 80 {
 b
 } else {
 return Err(ParseError::ExcludedBranch(1225514472166157741u64));
-})
-})())?;
-let field2 = ((|| {
+}
+};
+let _seq2 = {
 let b = _input.read_byte()?;
-PResult::Ok(if b == 78 {
+if b == 78 {
 b
 } else {
 return Err(ParseError::ExcludedBranch(1224415506115142500u64));
-})
-})())?;
-let field3 = ((|| {
+}
+};
+let _seq3 = {
 let b = _input.read_byte()?;
-PResult::Ok(if b == 71 {
+if b == 71 {
 b
 } else {
 return Err(ParseError::ExcludedBranch(16859485491091215361u64));
-})
-})())?;
-let field4 = ((|| {
+}
+};
+let _seq4 = {
 let b = _input.read_byte()?;
-PResult::Ok(if b == 13 {
+if b == 13 {
 b
 } else {
 return Err(ParseError::ExcludedBranch(14898840355839773829u64));
-})
-})())?;
-let field5 = ((|| {
+}
+};
+let _seq5 = {
 let b = _input.read_byte()?;
-PResult::Ok(if b == 10 {
+if b == 10 {
 b
 } else {
 return Err(ParseError::ExcludedBranch(9453951600195794313u64));
-})
-})())?;
-let field6 = ((|| {
+}
+};
+let _seq6 = {
 let b = _input.read_byte()?;
-PResult::Ok(if b == 26 {
+if b == 26 {
 b
 } else {
 return Err(ParseError::ExcludedBranch(10036157788440812915u64));
-})
-})())?;
-let field7 = ((|| {
+}
+};
+let _seq7 = {
 let b = _input.read_byte()?;
-PResult::Ok(if b == 10 {
+if b == 10 {
 b
 } else {
 return Err(ParseError::ExcludedBranch(6349531732377484771u64));
-})
-})())?;
-(field0, field1, field2, field3, field4, field5, field6, field7)
+}
+};
+vec![_seq0, _seq1, _seq2, _seq3, _seq4, _seq5, _seq6, _seq7]
 };
 let ihdr = (Decoder_png_ihdr(_input))?;
 let chunks = {
@@ -5162,7 +5163,7 @@ break
 accum
 };
 let iend = (Decoder_png_iend(_input))?;
-PResult::Ok(png_main { ihdr, chunks, idat, more_chunks, iend })
+PResult::Ok(png_main { signature, ihdr, chunks, idat, more_chunks, iend })
 }
 
 fn Decoder_riff_main<>(_input: &mut Parser<'_>) -> Result<riff_main, ParseError> {
diff --git a/src/codegen/mod.rs b/src/codegen/mod.rs
index 4fd2a409..57de1e08 100644
--- a/src/codegen/mod.rs
+++ b/src/codegen/mod.rs
@@ -313,6 +313,14 @@ impl CodeGen {
                             "TypedDecoder::Tuple expected to have type RustType::AnonTuple(..) (or UNIT if empty), found {other:?}"
                         ),
                 }
+            TypedDecoder::Sequence(gt, elts) => match gt {
+                GenType::Inline(RustType::Atom(AtomType::Comp(CompType::Vec(_t)))) => {
+                    let as_array = _t.prefer_array(elts.len());
+                    let elements = elts.iter().map(|elt| self.translate(elt.get_dec())).collect();
+                    CaseLogic::Sequential(SequentialLogic::AccumSeq { as_array, elements })
+                },
+                other => unreachable!("TypedDecoder::Sequence expected to have type CompType::Vec(..), found {other:?}"),
+            },
             TypedDecoder::Repeat0While(_gt, tree_continue, single) =>
                 CaseLogic::Repeat(
                     RepeatLogic::Repeat0ContinueOnMatch(
@@ -839,7 +847,11 @@ fn embed_expr(expr: &GTExpr, info: ExprInfo) -> RustExpr {
                 )
             )
         }
-
+        TypedExpr::Append(_, seq0, seq1) => {
+            let lhs = embed_expr(seq0, info);
+            let rhs = embed_expr(seq1, info);
+            RustExpr::FunctionCall(Box::new(RustExpr::local("seq_append")), vec![lhs, rhs])
+        }
         TypedExpr::SubSeq(_, seq, ix, len) => {
             let start_expr = embed_expr_dft(ix);
             let bind_ix = RustStmt::assign(
@@ -2751,7 +2763,12 @@ enum RepeatLogic<ExprT> {
     /// Fused logic for a left-fold that is updated on each repeat, and contributes to the condition for termination
     ///
     /// Lambda order: termination-predicate, then update-function
-    AccumUntil(GenLambda, GenLambda, Typed<RustExpr>, Typed<Box<CaseLogic<ExprT>>>),
+    AccumUntil(
+        GenLambda,
+        GenLambda,
+        Typed<RustExpr>,
+        Typed<Box<CaseLogic<ExprT>>>,
+    ),
 }
 
 pub(crate) type Typed<T> = (T, GenType);
@@ -3134,7 +3151,10 @@ where
                     loop_body.push(RustStmt::assign("elem", elt_expr));
                     loop_body.push(RustStmt::Expr(RustExpr::local("seq").call_method_with(
                         "push",
-                        [RustExpr::owned(RustExpr::local("elem"), elt_type.to_rust_type())],
+                        [RustExpr::owned(
+                            RustExpr::local("elem"),
+                            elt_type.to_rust_type(),
+                        )],
                     )));
                     let new_acc = update.apply_pair(
                         RustExpr::local("acc"),
@@ -3161,6 +3181,10 @@ enum SequentialLogic<ExprT> {
         constructor: Option<Constructor>,
         elements: Vec<CaseLogic<ExprT>>,
     },
+    AccumSeq {
+        as_array: bool,
+        elements: Vec<CaseLogic<ExprT>>,
+    },
 }
 
 impl<ExprT> ToAst for SequentialLogic<ExprT>
@@ -3171,6 +3195,27 @@ where
 
     fn to_ast(&self, ctxt: ProdCtxt<'_>) -> GenBlock {
         match self {
+            // REVIEW - in certain cases, we may be able to use fixed-sized arrays instead of vec, but that might complicate matters...
+            SequentialLogic::AccumSeq { as_array, elements } => {
+                if elements.is_empty() {
+                    return GenBlock::simple_expr(RustExpr::VEC_NIL);
+                }
+                let mut stmts = Vec::new();
+                let mut terms = Vec::new();
+
+                for (ix, cl) in elements.iter().enumerate() {
+                    const LAB_PREFIX: &str = "_seq";
+                    let lab = Label::Owned(format!("{LAB_PREFIX}{ix}"));
+                    stmts.push(GenStmt::BindOnce(lab.clone(), cl.to_ast(ctxt)));
+                    terms.push(RustExpr::local(lab));
+                }
+                let ret = Some(GenExpr::Embed(if *as_array {
+                    RustExpr::ArrayLit(terms)
+                } else {
+                    RustExpr::Macro(RustMacro::Vec(VecExpr::List(terms)))
+                }));
+                GenBlock { stmts, ret }
+            }
             SequentialLogic::AccumTuple {
                 constructor,
                 elements,
@@ -4141,6 +4186,24 @@ impl<'a> Elaborator<'a> {
                 let gt = self.get_gt_from_index(index);
                 TypedFormat::Tuple(gt, t_elts)
             }
+            Format::Sequence(formats) => {
+                let index = self.get_and_increment_index();
+                self.increment_index();
+                let t_formats = match &formats[..] {
+                    [] => unreachable!("empty list has no unambiguous type"),
+                    [v] => vec![self.elaborate_format(v, dyn_scope)],
+                    formats => {
+                        let mut t_formats = Vec::with_capacity(formats.len());
+                        for t in formats {
+                            let t_format = self.elaborate_format(t, dyn_scope);
+                            t_formats.push(t_format);
+                        }
+                        t_formats
+                    }
+                };
+                let gt = self.get_gt_from_index(index);
+                TypedFormat::Sequence(gt, t_formats)
+            }
             Format::Repeat(inner) => {
                 let index = self.get_and_increment_index();
                 let t_inner = self.elaborate_format(inner, dyn_scope);
@@ -4484,7 +4547,14 @@ impl<'a> Elaborator<'a> {
                 let gt = self.get_gt_from_index(index);
                 TypedExpr::Seq(gt, t_elts)
             }
+            Expr::Append(lhs, rhs) => {
+                let t_lhs = self.elaborate_expr(lhs);
+                let t_rhs = self.elaborate_expr(rhs);
+                self.increment_index();
 
+                let gt = self.get_gt_from_index(index);
+                TypedExpr::Append(gt, Box::new(t_lhs), Box::new(t_rhs))
+            }
             Expr::RecordProj(e, fld) => {
                 self.codegen.name_gen.ctxt.push_atom(NameAtom::DeadEnd);
                 let t_e = self.elaborate_expr(e);
diff --git a/src/codegen/rust_ast/mod.rs b/src/codegen/rust_ast/mod.rs
index e0c76efb..396889b4 100644
--- a/src/codegen/rust_ast/mod.rs
+++ b/src/codegen/rust_ast/mod.rs
@@ -685,6 +685,15 @@ impl RustType {
         }
     }
 
+    /// Returns `true` if seq-formats ([`Format::Sequence`]) of type `Seq(<self>)` should prefer to use
+    /// fixed-size arrays (`[T; N]`) over vectors (`Vec<T>`) during construction. An additional parameter,
+    /// the length of the sequence (`len`), is passed in to guide the decision, as simple types can be
+    /// preferable as vectors depending more on the length of the sequence than anything else.
+    pub(crate) fn prefer_array(&self, _n: usize) -> bool {
+        // REVIEW - currently, we would need to orchestrate the correct decision at multiple layers, which would take a lot of work
+        false
+    }
+
     /// Returns `true` if `self` is a known-`Copy` `RustType`.
     ///
     /// # Note
@@ -1399,6 +1408,17 @@ pub(crate) enum RustExpr {
 #[derive(Debug, Clone)]
 pub(crate) enum RustMacro {
     Matches(Box<RustExpr>, Vec<RustPattern>),
+    Vec(VecExpr),
+}
+
+#[derive(Debug, Clone)]
+pub(crate) enum VecExpr {
+    Nil,
+    #[expect(dead_code)]
+    Single(Box<RustExpr>),
+    #[expect(dead_code)]
+    Repeat(Box<RustExpr>, Box<RustExpr>),
+    List(Vec<RustExpr>),
 }
 
 impl RustExpr {
@@ -1410,6 +1430,8 @@ impl RustExpr {
 
     pub const FALSE: Self = Self::PrimitiveLit(RustPrimLit::Boolean(false));
 
+    pub const VEC_NIL: Self = RustExpr::Macro(RustMacro::Vec(VecExpr::Nil));
+
     /// Returns `Some(varname)` if `self` is a simple entity-reference to identifier `varname`, and
     /// `None` otherwise.
     pub fn as_local(&self) -> Option<&Label> {
@@ -1490,12 +1512,15 @@ impl RustExpr {
             Self::Owned(OwnedRustExpr { expr, .. }) => match &*expr {
                 Self::FieldAccess(..) => Self::Borrow(expr),
                 _ => *expr,
-            }
+            },
             other => Self::Borrow(Box::new(other)),
         }
     }
 
-    pub fn field<Name>(self, name: Name) -> Self where Name: Into<Label> + AsRef<str> {
+    pub fn field<Name>(self, name: Name) -> Self
+    where
+        Name: Into<Label> + AsRef<str>,
+    {
         match self {
             Self::Owned(OwnedRustExpr { expr, kind }) => {
                 let (expr, kind) = match kind {
@@ -1504,7 +1529,7 @@ impl RustExpr {
                         let lens = lens.field(lab.clone());
                         (Box::new(expr.field(lab)), OwnedKind::Unresolved(lens))
                     }
-                    _ => (Box::new(expr.field(name)), kind)
+                    _ => (Box::new(expr.field(name)), kind),
                 };
                 Self::Owned(OwnedRustExpr { expr, kind })
             }
@@ -1531,17 +1556,26 @@ impl RustExpr {
     pub fn index(self, ix: RustExpr) -> RustExpr {
         match self {
             Self::Owned(owned) => match owned {
-                OwnedRustExpr { kind: OwnedKind::Copied | OwnedKind::Deref, expr: this } => this.index(ix),
-                OwnedRustExpr { kind: OwnedKind::Unresolved(lens), expr }  => {
-                    Self::Owned(OwnedRustExpr {
-                        expr: Box::new(expr.index(ix)),
-                        kind: OwnedKind::Unresolved(lens.elem()),
-                    })
-                },
-                OwnedRustExpr { kind: OwnedKind::Cloned, .. }  => {
-                    unreachable!("index smart-constructor should only be used on undecided expressions");
+                OwnedRustExpr {
+                    kind: OwnedKind::Copied | OwnedKind::Deref,
+                    expr: this,
+                } => this.index(ix),
+                OwnedRustExpr {
+                    kind: OwnedKind::Unresolved(lens),
+                    expr,
+                } => Self::Owned(OwnedRustExpr {
+                    expr: Box::new(expr.index(ix)),
+                    kind: OwnedKind::Unresolved(lens.elem()),
+                }),
+                OwnedRustExpr {
+                    kind: OwnedKind::Cloned,
+                    ..
+                } => {
+                    unreachable!(
+                        "index smart-constructor should only be used on undecided expressions"
+                    );
                 }
-            }
+            },
             other => Self::Index(Box::new(other), Box::new(ix)),
         }
     }
@@ -1563,7 +1597,7 @@ impl RustExpr {
     /// clone-then-borrow constructs in the generated code.
     pub fn vec_as_slice(self) -> Self {
         let this = match self {
-            Self::Owned(OwnedRustExpr {expr, .. }) => *expr,
+            Self::Owned(OwnedRustExpr { expr, .. }) => *expr,
             other => other,
         };
         this.call_method("as_slice")
@@ -1640,6 +1674,7 @@ impl RustExpr {
                 RustPrimLit::String(..) => None,
             },
             RustExpr::Macro(RustMacro::Matches(..)) => Some(PrimType::Bool),
+            RustExpr::Macro(RustMacro::Vec(..)) => None,
             RustExpr::ArrayLit(..) => None,
             RustExpr::MethodCall(_recv, _method, _args) => {
                 match _method {
@@ -1788,6 +1823,12 @@ impl RustExpr {
         match self {
             RustExpr::Entity(..) => true,
             RustExpr::Macro(RustMacro::Matches(expr, ..)) => expr.is_pure(),
+            RustExpr::Macro(RustMacro::Vec(vec_expr)) => match vec_expr {
+                VecExpr::Nil => true,
+                VecExpr::Single(x) => x.is_pure(),
+                VecExpr::Repeat(x, n) => x.is_pure() && n.is_pure(),
+                VecExpr::List(xs) => xs.iter().all(Self::is_pure),
+            },
             RustExpr::PrimitiveLit(..) => true,
             RustExpr::ArrayLit(arr) => arr.iter().all(Self::is_pure),
             // REVIEW - over types we have no control over, clone itself can be impure, but it should never be so for the code we ourselves are generating
@@ -1810,9 +1851,7 @@ impl RustExpr {
                 StructExpr::TupleExpr(values) => values.iter().all(|val| val.is_pure()),
                 StructExpr::EmptyExpr => true,
             },
-            RustExpr::Borrow(expr) | RustExpr::BorrowMut(expr) => {
-                expr.is_pure()
-            }
+            RustExpr::Borrow(expr) | RustExpr::BorrowMut(expr) => expr.is_pure(),
             // NOTE - while we can construct pure Try-expressions manually, the intent of `?` is to have potential side-effects and so we judge them de-facto impure
             RustExpr::Try(..) => false,
             RustExpr::Operation(op) => match op {
@@ -1872,6 +1911,8 @@ impl RustExpr {
 
             // Special case - `matches!` macro is an idiomatic conditional expression
             RustExpr::Macro(RustMacro::Matches(..)) => false,
+            // Special case - `vec!` will typically be constructed only over simple sub-expressions
+            RustExpr::Macro(RustMacro::Vec(..)) => false,
 
             // REVIEW - is there a better heuristic?
             RustExpr::Closure(..) => true,
@@ -1983,14 +2024,39 @@ impl RustExpr {
 
     pub(crate) fn owned(loc: RustExpr, expr_type: RustType) -> RustExpr {
         let owned = if expr_type.can_be_copy() {
-            OwnedRustExpr { expr: Box::new(loc), kind: OwnedKind::Copied }
+            OwnedRustExpr {
+                expr: Box::new(loc),
+                kind: OwnedKind::Copied,
+            }
         } else {
-            OwnedRustExpr { expr: Box::new(loc), kind: OwnedKind::Unresolved(Lens::Ground(expr_type)) }
+            OwnedRustExpr {
+                expr: Box::new(loc),
+                kind: OwnedKind::Unresolved(Lens::Ground(expr_type)),
+            }
         };
         RustExpr::Owned(owned)
     }
 }
 
+impl ToFragment for VecExpr {
+    fn to_fragment(&self) -> Fragment {
+        let contents = match self {
+            VecExpr::Nil => Fragment::Empty,
+            VecExpr::Single(x) => x.to_fragment_precedence(Precedence::Top),
+            VecExpr::Repeat(x, n) => x.to_fragment_precedence(Precedence::Top).intervene(
+                Fragment::string("; "),
+                n.to_fragment_precedence(Precedence::Top),
+            ),
+            VecExpr::List(elts) => Fragment::seq(
+                elts.iter()
+                    .map(|x| x.to_fragment_precedence(Precedence::Top)),
+                Some(Fragment::string(", ")),
+            ),
+        };
+        contents.delimit(Fragment::Char('['), Fragment::Char(']'))
+    }
+}
+
 impl ToFragmentExt for RustExpr {
     fn to_fragment_precedence(&self, prec: Precedence) -> Fragment {
         match self {
@@ -2035,19 +2101,27 @@ impl ToFragmentExt for RustExpr {
                 prec,
                 Precedence::INVOKE,
             ),
-            RustExpr::Owned(OwnedRustExpr { expr: x, kind: OwnedKind::Cloned }) => cond_paren(
+            RustExpr::Owned(OwnedRustExpr {
+                expr: x,
+                kind: OwnedKind::Cloned,
+            }) => cond_paren(
                 x.to_fragment_precedence(Precedence::Projection)
                     .intervene(Fragment::Char('.'), Fragment::string("clone()")),
                 prec,
                 Precedence::Projection,
             ),
-            RustExpr::Owned(OwnedRustExpr { kind: OwnedKind::Deref, expr}) => {
-                Fragment::Char('*').cat(expr.to_fragment_precedence(Precedence::Prefix))
-            }
-            RustExpr::Owned(OwnedRustExpr { kind: OwnedKind::Copied, expr }) => {
-                expr.to_fragment_precedence(prec)
-            }
-            RustExpr::Owned(OwnedRustExpr { kind: OwnedKind::Unresolved(lens), expr}) => {
+            RustExpr::Owned(OwnedRustExpr {
+                kind: OwnedKind::Deref,
+                expr,
+            }) => Fragment::Char('*').cat(expr.to_fragment_precedence(Precedence::Prefix)),
+            RustExpr::Owned(OwnedRustExpr {
+                kind: OwnedKind::Copied,
+                expr,
+            }) => expr.to_fragment_precedence(prec),
+            RustExpr::Owned(OwnedRustExpr {
+                kind: OwnedKind::Unresolved(lens),
+                expr,
+            }) => {
                 unreachable!("unresolved ownership: ({expr:?}: {lens:?})")
             }
             RustExpr::FieldAccess(x, name) => x
@@ -2070,6 +2144,9 @@ impl ToFragmentExt for RustExpr {
                         .delimit(Fragment::Char('('), Fragment::Char(')')),
                 )
                 .group(),
+            RustExpr::Macro(RustMacro::Vec(vec_expr)) => {
+                Fragment::string("vec!").cat(vec_expr.to_fragment())
+            }
             RustExpr::Tuple(elts) => match elts.as_slice() {
                 [elt] => elt
                     .to_fragment_precedence(Precedence::Top)
@@ -3096,7 +3173,8 @@ mod test {
 
 pub mod short_circuit {
     use super::{
-        OwnedRustExpr, ReturnKind, RustCatchAll, RustControl, RustExpr, RustMacro, RustMatchBody, RustMatchCase, RustOp, RustStmt, StructExpr
+        OwnedRustExpr, ReturnKind, RustCatchAll, RustControl, RustExpr, RustMacro, RustMatchBody,
+        RustMatchCase, RustOp, RustStmt, StructExpr, VecExpr,
     };
 
     #[derive(Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Debug, Hash)]
@@ -3104,9 +3182,9 @@ pub mod short_circuit {
         /// Can never constitute a short-circuit
         Pure = 0,
         /// Short-circuit if and only if it is the only non-pure term in a terminal value-producing node
-        SemiPure = 1,
-        /// Constitutes a potential short-circuit regardless of context
-        Impure = 2,
+        Try = 1,
+        /// Explicit `return` keyword -- constitutes a potential short-circuit regardless of context
+        Return = 2,
     }
 
     impl std::ops::BitOr for EvalPurity {
@@ -3115,21 +3193,22 @@ pub mod short_circuit {
         fn bitor(self, rhs: Self) -> Self::Output {
             match self {
                 EvalPurity::Pure => rhs,
-                EvalPurity::SemiPure => match rhs {
-                    EvalPurity::Pure => self,
-                    _ => EvalPurity::Impure,
+                EvalPurity::Try => match rhs {
+                    EvalPurity::Return => EvalPurity::Return,
+                    _ => self,
                 },
-                EvalPurity::Impure => EvalPurity::Impure,
+                EvalPurity::Return => EvalPurity::Return,
             }
         }
     }
 
     impl std::ops::BitOrAssign for EvalPurity {
         fn bitor_assign(&mut self, rhs: Self) {
-            match (&self, rhs) {
-                (EvalPurity::Pure, _) | (_, EvalPurity::Impure) => *self = rhs,
-                (EvalPurity::Impure, _) | (_, EvalPurity::Pure) => (),
-                (EvalPurity::SemiPure, EvalPurity::SemiPure) => *self = EvalPurity::Impure,
+            if matches!(
+                (&self, rhs),
+                (EvalPurity::Pure, _) | (_, EvalPurity::Return)
+            ) {
+                *self = rhs;
             }
         }
     }
@@ -3150,8 +3229,8 @@ pub mod short_circuit {
         fn has_short_circuit(&self, is_last: bool) -> bool {
             match self.check_eval_purity() {
                 EvalPurity::Pure => false,
-                EvalPurity::SemiPure => !is_last,
-                EvalPurity::Impure => true,
+                EvalPurity::Try => !is_last,
+                EvalPurity::Return => true,
             }
         }
     }
@@ -3234,7 +3313,7 @@ pub mod short_circuit {
                 | RustStmt::Let(.., expr)
                 | RustStmt::LetPattern(.., expr)
                 | RustStmt::Return(ReturnKind::Implicit, expr) => expr.check_eval_purity(),
-                RustStmt::Return(ReturnKind::Keyword, ..) => EvalPurity::SemiPure,
+                RustStmt::Return(ReturnKind::Keyword, ..) => EvalPurity::Try,
                 RustStmt::Control(ctrl) => ctrl.check_eval_purity(),
             }
         }
@@ -3329,7 +3408,7 @@ pub mod short_circuit {
             match self {
                 RustMatchBody::Irrefutable(branches) => branches.check_eval_purity(),
                 RustMatchBody::Refutable(branches, rust_catch_all) => match rust_catch_all {
-                    RustCatchAll::ReturnErrorValue { .. } => EvalPurity::SemiPure,
+                    RustCatchAll::ReturnErrorValue { .. } => EvalPurity::Try,
                     RustCatchAll::PanicUnreachable { .. } => branches.check_eval_purity(),
                 },
             }
@@ -3372,6 +3451,7 @@ pub mod short_circuit {
                     stmts.is_short_circuiting() || expr.is_short_circuiting()
                 }
                 RustExpr::Macro(RustMacro::Matches(expr, ..)) => expr.is_short_circuiting(),
+                RustExpr::Macro(RustMacro::Vec(vec_expr)) => vec_expr.is_short_circuiting(),
                 RustExpr::Control(ctrl) => ctrl.is_short_circuiting(),
                 RustExpr::Closure(..) => false,
                 RustExpr::Index(head, index) => {
@@ -3396,7 +3476,7 @@ pub mod short_circuit {
                     fn check_eval_purity(&self) -> EvalPurity {
                         let mut acc = EvalPurity::Pure;
                         for expr in self.iter() {
-                            if acc == EvalPurity::Impure { break; }
+                            if acc == EvalPurity::Return { break; }
                             acc |= expr.check_eval_purity();
                         }
                         acc
@@ -3410,8 +3490,8 @@ pub mod short_circuit {
         fn check_eval_purity(&self) -> EvalPurity {
             let mut acc = EvalPurity::Pure;
             for expr in self.iter() {
-                if matches!(acc, EvalPurity::SemiPure | EvalPurity::Impure) {
-                    return EvalPurity::Impure;
+                if matches!(acc, EvalPurity::Try | EvalPurity::Return) {
+                    return EvalPurity::Return;
                 }
                 acc |= expr.check_eval_purity();
             }
@@ -3441,13 +3521,14 @@ pub mod short_circuit {
                 | RustExpr::BorrowMut(inner) => inner.check_eval_purity(),
                 RustExpr::Try(inner) => match inner.as_ref() {
                     RustExpr::ResultOk(.., expr) => expr.check_eval_purity(),
-                    _ => EvalPurity::SemiPure,
+                    _ => EvalPurity::Try,
                 },
                 RustExpr::Operation(op) => op.check_eval_purity(),
                 RustExpr::BlockScope(stmts, expr) => {
                     stmts.check_eval_purity() | expr.check_eval_purity()
                 }
                 RustExpr::Macro(RustMacro::Matches(expr, ..)) => expr.check_eval_purity(),
+                RustExpr::Macro(RustMacro::Vec(vec_expr)) => vec_expr.check_eval_purity(),
                 RustExpr::Control(ctrl) => ctrl.check_eval_purity(),
                 RustExpr::Index(head, index) => {
                     head.check_eval_purity() | index.check_eval_purity()
@@ -3462,6 +3543,28 @@ pub mod short_circuit {
         }
     }
 
+    impl ShortCircuit for VecExpr {
+        fn is_short_circuiting(&self) -> bool {
+            match self {
+                VecExpr::Nil => false,
+                VecExpr::Single(x) => x.is_short_circuiting(),
+                VecExpr::Repeat(x, n) => x.is_short_circuiting() || n.is_short_circuiting(),
+                VecExpr::List(xs) => xs.is_short_circuiting(),
+            }
+        }
+    }
+
+    impl ShortCircuitExt for VecExpr {
+        fn check_eval_purity(&self) -> EvalPurity {
+            match self {
+                VecExpr::Nil => EvalPurity::Pure,
+                VecExpr::Single(x) => x.check_eval_purity(),
+                VecExpr::Repeat(x, n) => x.check_eval_purity() | n.check_eval_purity(),
+                VecExpr::List(xs) => xs.check_eval_purity(),
+            }
+        }
+    }
+
     impl ShortCircuit for RustOp {
         fn is_short_circuiting(&self) -> bool {
             match self {
@@ -3523,7 +3626,9 @@ pub use short_circuit::{ShortCircuit, ShortCircuitExt, ValueCheckpoint};
 
 pub mod var_container {
     use super::{
-        ClosureBody, MatchCaseLHS, OwnedRustExpr, RustCatchAll, RustClosure, RustClosureHead, RustControl, RustEntity, RustExpr, RustMacro, RustMatchBody, RustMatchCase, RustOp, RustPattern, RustStmt, StructExpr
+        ClosureBody, MatchCaseLHS, OwnedRustExpr, RustCatchAll, RustClosure, RustClosureHead,
+        RustControl, RustEntity, RustExpr, RustMacro, RustMatchBody, RustMatchCase, RustOp,
+        RustPattern, RustStmt, StructExpr, VecExpr,
     };
 
     pub trait VarBinder {
@@ -3721,6 +3826,7 @@ pub mod var_container {
                         || (!stmts.binds_var(var) && expr.contains_var_ref(var))
                 }
                 RustExpr::Macro(RustMacro::Matches(expr, ..)) => expr.contains_var_ref(var),
+                RustExpr::Macro(RustMacro::Vec(vec_expr)) => vec_expr.contains_var_ref(var),
                 RustExpr::Control(ctrl) => ctrl.contains_var_ref(var),
                 RustExpr::PrimitiveLit(..) => false,
                 RustExpr::ArrayLit(rust_exprs) => {
@@ -3741,6 +3847,20 @@ pub mod var_container {
         }
     }
 
+    impl VarContainer for VecExpr {
+        fn contains_var_ref<Name>(&self, var: &Name) -> bool
+        where
+            Name: AsRef<str> + ?Sized,
+        {
+            match self {
+                VecExpr::Nil => false,
+                VecExpr::Single(x) => x.contains_var_ref(var),
+                VecExpr::Repeat(x, n) => x.contains_var_ref(var) || n.contains_var_ref(var),
+                VecExpr::List(xs) => xs.contains_var_ref(var),
+            }
+        }
+    }
+
     impl VarContainer for RustClosure {
         fn contains_var_ref<Name>(&self, var: &Name) -> bool
         where
diff --git a/src/codegen/rust_ast/rebind.rs b/src/codegen/rust_ast/rebind.rs
index 242db4e6..f27bee42 100644
--- a/src/codegen/rust_ast/rebind.rs
+++ b/src/codegen/rust_ast/rebind.rs
@@ -133,23 +133,32 @@ impl Rebindable for RustExpr {
                 pats.rebind(table);
             }
             RustExpr::Tuple(elts) => elts.rebind(table),
+            RustExpr::Macro(RustMacro::Vec(vec_expr)) => match vec_expr {
+                VecExpr::Nil => (),
+                VecExpr::Single(x) => x.rebind(table),
+                VecExpr::Repeat(x, n) => {
+                    x.rebind(table);
+                    n.rebind(table);
+                }
+                VecExpr::List(rust_exprs) => {
+                    rust_exprs.rebind(table);
+                }
+            },
             RustExpr::Struct(con, expr) => {
                 con.rebind(table);
                 match expr {
+                    StructExpr::EmptyExpr => (),
+                    StructExpr::TupleExpr(vals) => vals.rebind(table),
                     StructExpr::RecordExpr(flds) => {
                         flds.iter_mut().for_each(|(_, fld)| fld.rebind(table))
                     }
-                    StructExpr::TupleExpr(vals) => {
-                        vals.iter_mut().for_each(|val| val.rebind(table))
-                    }
-                    StructExpr::EmptyExpr => (),
                 }
             }
             RustExpr::Owned(owned) => owned.rebind(table),
 
-            RustExpr::Borrow(inner)
-            | RustExpr::BorrowMut(inner)
-            | RustExpr::Try(inner) => inner.rebind(table),
+            RustExpr::Borrow(inner) | RustExpr::BorrowMut(inner) | RustExpr::Try(inner) => {
+                inner.rebind(table)
+            }
             RustExpr::Operation(oper) => oper.rebind(table),
             RustExpr::BlockScope(stmts, ret) => {
                 stmts.rebind(table);
@@ -382,7 +391,10 @@ impl Rebindable for CompType {
 impl Rebindable for OwnedRustExpr {
     fn rebind(&mut self, table: &impl MapLike<Label, Label>) {
         match self {
-            OwnedRustExpr { expr, kind: OwnedKind::Unresolved(lens) } => {
+            OwnedRustExpr {
+                expr,
+                kind: OwnedKind::Unresolved(lens),
+            } => {
                 expr.rebind(table);
                 lens.rebind(table);
             }
@@ -391,8 +403,10 @@ impl Rebindable for OwnedRustExpr {
     }
 }
 
-
-impl<T> Rebindable for Lens<T> where T: Rebindable {
+impl<T> Rebindable for Lens<T>
+where
+    T: Rebindable,
+{
     fn rebind(&mut self, table: &impl MapLike<Label, Label>) {
         match self {
             Lens::Ground(typ) => typ.rebind(table),
diff --git a/src/codegen/rust_ast/resolve.rs b/src/codegen/rust_ast/resolve.rs
index 21d9214f..4b9d0ac4 100644
--- a/src/codegen/rust_ast/resolve.rs
+++ b/src/codegen/rust_ast/resolve.rs
@@ -1,5 +1,5 @@
-use crate::codegen::rust_ast::analysis::SourceContext;
 use super::*;
+use crate::codegen::rust_ast::analysis::SourceContext;
 
 pub(crate) struct Solution {
     is_copy: bool,
@@ -65,7 +65,7 @@ impl Resolvable for RustStmt {
             | RustStmt::Reassign(.., expr)
             | RustStmt::Return(.., expr)
             | RustStmt::Expr(expr) => expr.resolve(ctx),
-            RustStmt::Control(ctrl) => ctrl.resolve(ctx)
+            RustStmt::Control(ctrl) => ctrl.resolve(ctx),
         }
     }
 }
@@ -88,7 +88,9 @@ impl Resolvable for RustControl {
             RustControl::Match(expr, body) => {
                 expr.resolve(ctx);
                 match body {
-                    RustMatchBody::Irrefutable(items) => items.iter_mut().for_each(|(_, item)| item.resolve(ctx)),
+                    RustMatchBody::Irrefutable(items) => {
+                        items.iter_mut().for_each(|(_, item)| item.resolve(ctx))
+                    }
                     RustMatchBody::Refutable(items, rust_catch_all) => match rust_catch_all {
                         RustCatchAll::PanicUnreachable { .. } => {
                             items.iter_mut().for_each(|(_, item)| item.resolve(ctx))
@@ -97,7 +99,7 @@ impl Resolvable for RustControl {
                             value.resolve(ctx);
                             items.iter_mut().for_each(|(_, item)| item.resolve(ctx))
                         }
-                    }
+                    },
                 }
             }
             RustControl::Break => (),
@@ -105,7 +107,6 @@ impl Resolvable for RustControl {
     }
 }
 
-
 impl Resolvable for RustExpr {
     fn resolve(&mut self, ctx: &SourceContext<'_>) {
         match self {
@@ -131,6 +132,15 @@ impl Resolvable for RustExpr {
             | RustExpr::ResultErr(expr)
             | RustExpr::Macro(RustMacro::Matches(expr, _))
             | RustExpr::BorrowMut(expr) => expr.resolve(ctx),
+            RustExpr::Macro(RustMacro::Vec(v)) => match v {
+                VecExpr::Nil => (),
+                VecExpr::Single(expr) => expr.resolve(ctx),
+                VecExpr::Repeat(expr, count) => {
+                    expr.resolve(ctx);
+                    count.resolve(ctx);
+                }
+                VecExpr::List(exprs) => exprs.resolve(ctx),
+            },
             RustExpr::Operation(op) => op.resolve(ctx),
             RustExpr::BlockScope(stmts, expr) => {
                 stmts.resolve(ctx);
@@ -140,7 +150,7 @@ impl Resolvable for RustExpr {
             RustExpr::Closure(closure) => match &mut closure.1 {
                 ClosureBody::Expression(expr) => expr.resolve(ctx),
                 ClosureBody::Statements(stmts) => stmts.resolve(ctx),
-            }
+            },
             RustExpr::Index(expr, ix) => {
                 expr.resolve(ctx);
                 ix.resolve(ctx);
@@ -165,8 +175,7 @@ impl Resolvable for RustOp {
                 lhs.resolve(ctx);
                 rhs.resolve(ctx);
             }
-            RustOp::PrefixOp(_, expr)
-            | RustOp::AsCast(expr, _) => expr.resolve(ctx),
+            RustOp::PrefixOp(_, expr) | RustOp::AsCast(expr, _) => expr.resolve(ctx),
         }
     }
 }
@@ -204,7 +213,10 @@ impl Resolvable for OwnedRustExpr {
 fn solve_type(ty: &RustType, ctx: &SourceContext<'_>) -> Solution {
     match ty {
         RustType::Atom(at) => match at {
-            AtomType::Prim(_) => Solution { is_copy: true, is_ref: false },
+            AtomType::Prim(_) => Solution {
+                is_copy: true,
+                is_ref: false,
+            },
             AtomType::TypeRef(lt) => match lt {
                 LocalType::LocalDef(ix, ..) => {
                     let is_copy = ctx.get_copy(*ix);
@@ -212,23 +224,35 @@ fn solve_type(ty: &RustType, ctx: &SourceContext<'_>) -> Solution {
                     Solution { is_copy, is_ref }
                 }
                 LocalType::External(..) => unreachable!("external type cannot be solved"),
-            }
+            },
             AtomType::Comp(ct) => match ct {
-                CompType::Vec(..) => Solution { is_copy: false, is_ref: false },
+                CompType::Vec(..) => Solution {
+                    is_copy: false,
+                    is_ref: false,
+                },
                 CompType::RawSlice(elt) => {
                     let Solution { is_copy, .. } = solve_type(&elt, ctx);
-                    Solution { is_copy, is_ref: false }
+                    Solution {
+                        is_copy,
+                        is_ref: false,
+                    }
                 }
                 CompType::Option(inner) | CompType::Result(inner, _) => {
                     let Solution { is_copy, .. } = solve_type(&inner, ctx);
-                    Solution { is_copy, is_ref: false }
+                    Solution {
+                        is_copy,
+                        is_ref: false,
+                    }
                 }
                 CompType::Borrow(.., t) => {
                     let Solution { is_copy, .. } = solve_type(&t, ctx);
-                    Solution { is_copy, is_ref: true }
+                    Solution {
+                        is_copy,
+                        is_ref: true,
+                    }
                 }
-            }
-        }
+            },
+        },
         RustType::AnonTuple(rust_types) => {
             let mut is_copy = true;
             for ty in rust_types.iter() {
@@ -266,10 +290,15 @@ fn get_field_def(def: &RustTypeDef, lab: &str) -> RustType {
     match def {
         RustTypeDef::Enum(..) => unreachable!("bad Field on enum: {def:?}"),
         RustTypeDef::Struct(str) => match str {
-            RustStruct::Record(fields) => fields.iter().find(|f| f.0.as_ref() == lab).cloned().unwrap_or_else(|| {
-                panic!("missing field `{lab}` in {def:?}")
-            }).1
-        }
+            RustStruct::Record(fields) => {
+                fields
+                    .iter()
+                    .find(|f| f.0.as_ref() == lab)
+                    .cloned()
+                    .unwrap_or_else(|| panic!("missing field `{lab}` in {def:?}"))
+                    .1
+            }
+        },
     }
 }
 
@@ -282,13 +311,13 @@ fn get_field(ty: &RustType, lab: &str, ctx: &SourceContext<'_>) -> RustType {
                     get_field_def(def, lab)
                 }
                 LocalType::External(..) => unreachable!("external type cannot be solved: {ty:?}"),
-            }
+            },
             AtomType::Comp(ct) => match ct {
                 CompType::Borrow(.., ty0) => get_field(ty0, lab, ctx),
                 _ => unreachable!("bad Field on non-record: {ty:?}"),
-            }
+            },
             _ => unreachable!("bad Field on non-record: {ty:?}"),
-        }
+        },
         _ => unreachable!("bad Field on non-record: {ty:?}"),
     }
 }
@@ -300,11 +329,11 @@ fn get_elem(ty: &RustType, ctx: &SourceContext<'_>) -> RustType {
                 CompType::RawSlice(ty0) | CompType::Vec(ty0) => ty0.as_ref().clone(),
                 CompType::Borrow(.., ty) => get_elem(ty.as_ref(), ctx),
                 _ => unreachable!("bad ElemOf on non-array: {ty:?}"),
-            }
+            },
             _ => unreachable!("bad ElemOf on non-array: {ty:?}"),
-        }
+        },
         _ => unreachable!("bad ElemOf on non-array: {ty:?}"),
-}
+    }
 }
 
 fn get_pos(ty: &RustType, ix: usize, ctx: &SourceContext<'_>) -> RustType {
@@ -314,9 +343,9 @@ fn get_pos(ty: &RustType, ix: usize, ctx: &SourceContext<'_>) -> RustType {
             AtomType::Comp(ct) => match ct {
                 CompType::Borrow(.., ty) => get_pos(ty.as_ref(), ix, ctx),
                 _ => unreachable!("bad Position on non-tuple: {ty:?}"),
-            }
+            },
             _ => unreachable!("bad Position on non-tuple: {ty:?}"),
-        }
+        },
         _ => unreachable!("bad Position on non-tuple: {ty:?}"),
     }
 }
diff --git a/src/codegen/typed_decoder.rs b/src/codegen/typed_decoder.rs
index 877e8789..05bb0d83 100644
--- a/src/codegen/typed_decoder.rs
+++ b/src/codegen/typed_decoder.rs
@@ -64,6 +64,7 @@ impl TypedDecoder<GenType> {
             | TypedDecoder::Parallel(t, ..)
             | TypedDecoder::Branch(t, ..)
             | TypedDecoder::Tuple(t, ..)
+            | TypedDecoder::Sequence(t, ..)
             | TypedDecoder::Repeat0While(t, ..)
             | TypedDecoder::Repeat1Until(t, ..)
             | TypedDecoder::RepeatCount(t, ..)
@@ -106,6 +107,7 @@ pub(crate) enum TypedDecoder<TypeRep> {
     Parallel(TypeRep, Vec<TypedDecoderExt<TypeRep>>),
     Branch(TypeRep, MatchTree, Vec<TypedDecoderExt<TypeRep>>),
     Tuple(TypeRep, Vec<TypedDecoderExt<TypeRep>>),
+    Sequence(TypeRep, Vec<TypedDecoderExt<TypeRep>>),
     Repeat0While(TypeRep, MatchTree, Box<TypedDecoderExt<TypeRep>>),
     Repeat1Until(TypeRep, MatchTree, Box<TypedDecoderExt<TypeRep>>),
     RepeatCount(
@@ -386,7 +388,7 @@ impl<'a> GTCompiler<'a> {
                 let mut dfields = Vec::with_capacity(fields.len());
                 let mut fields = fields.iter();
                 while let Some(f) = fields.next() {
-                    let next = Rc::new(Next::Tuple(
+                    let next = Rc::new(Next::Sequence(
                         MaybeTyped::Typed(fields.as_slice()),
                         next.clone(),
                     ));
@@ -395,6 +397,19 @@ impl<'a> GTCompiler<'a> {
                 }
                 Ok(TypedDecoder::Tuple(gt.clone(), dfields))
             }
+            TypedFormat::Sequence(gt, fields) => {
+                let mut dfields = Vec::with_capacity(fields.len());
+                let mut fields = fields.iter();
+                while let Some(f) = fields.next() {
+                    let next = Rc::new(Next::Sequence(
+                        MaybeTyped::Typed(fields.as_slice()),
+                        next.clone(),
+                    ));
+                    let df = self.compile_gt_format(f, None, next)?;
+                    dfields.push(df);
+                }
+                Ok(TypedDecoder::Sequence(gt.clone(), dfields))
+            }
             TypedFormat::Repeat(gt, a) => {
                 if a.as_ref().is_nullable() {
                     return Err(anyhow!("cannot repeat nullable format: {a:?}"));
diff --git a/src/codegen/typed_format.rs b/src/codegen/typed_format.rs
index 8dd10248..36a43d34 100644
--- a/src/codegen/typed_format.rs
+++ b/src/codegen/typed_format.rs
@@ -82,6 +82,8 @@ impl<TypeRep> std::hash::Hash for TypedFormat<TypeRep> {
                 branches.hash(state)
             }
             TypedFormat::Tuple(_, elts) => elts.hash(state),
+            // REVIEW - do we want to dodge collision between Tuple and Sequence with a salt, or is this okay?
+            TypedFormat::Sequence(_, elts) => elts.hash(state),
             TypedFormat::RepeatCount(_, n, inner) => {
                 n.hash(state);
                 inner.hash(state);
@@ -185,7 +187,7 @@ pub enum TypedFormat<TypeRep> {
     Union(TypeRep, Vec<TypedFormat<TypeRep>>),
     UnionNondet(TypeRep, Vec<TypedFormat<TypeRep>>),
     Tuple(TypeRep, Vec<TypedFormat<TypeRep>>),
-    // Record(TypeRep, Vec<(Label, TypedFormat<TypeRep>)>),
+    Sequence(TypeRep, Vec<TypedFormat<TypeRep>>),
     Repeat(TypeRep, Box<TypedFormat<TypeRep>>),
     Repeat1(TypeRep, Box<TypedFormat<TypeRep>>),
     RepeatCount(TypeRep, Box<TypedExpr<TypeRep>>, Box<TypedFormat<TypeRep>>),
@@ -281,7 +283,8 @@ impl TypedFormat<GenType> {
                 .map(TypedFormat::lookahead_bounds)
                 .reduce(Bounds::union)
                 .unwrap(),
-            TypedFormat::Tuple(_, elts) => elts
+            // REVIEW - we have a more sophisticated algorithm in Format::lookahead_bounds for Sequence, should we use that here?
+            TypedFormat::Tuple(_, elts) | TypedFormat::Sequence(_, elts) => elts
                 .iter()
                 .map(TypedFormat::lookahead_bounds)
                 .reduce(<Bounds as Add>::add)
@@ -353,7 +356,7 @@ impl TypedFormat<GenType> {
                 .map(TypedFormat::match_bounds)
                 .reduce(Bounds::union)
                 .unwrap(),
-            TypedFormat::Tuple(_, elts) => elts
+            TypedFormat::Sequence(_, elts) | TypedFormat::Tuple(_, elts) => elts
                 .iter()
                 .map(TypedFormat::match_bounds)
                 .reduce(<Bounds as Add>::add)
@@ -439,6 +442,7 @@ impl TypedFormat<GenType> {
             | TypedFormat::Union(gt, ..)
             | TypedFormat::UnionNondet(gt, ..)
             | TypedFormat::Tuple(gt, ..)
+            | TypedFormat::Sequence(gt, ..)
             | TypedFormat::Repeat(gt, ..)
             | TypedFormat::Repeat1(gt, ..)
             | TypedFormat::ForEach(gt, ..)
@@ -622,6 +626,11 @@ where
         TypedPattern<TypeRep>,
         Box<TypedExpr<TypeRep, VarId>>,
     ),
+    Append(
+        TypeRep,
+        Box<TypedExpr<TypeRep, VarId>>,
+        Box<TypedExpr<TypeRep, VarId>>,
+    ),
 }
 
 impl<TypeRep> std::hash::Hash for TypedExpr<TypeRep> {
@@ -730,6 +739,10 @@ impl<TypeRep> std::hash::Hash for TypedExpr<TypeRep> {
                 to.hash(state);
             }
             TypedExpr::LiftOption(_, opt) => opt.hash(state),
+            TypedExpr::Append(_, lhs, rhs) => {
+                lhs.hash(state);
+                rhs.hash(state);
+            }
         }
     }
 }
@@ -785,6 +798,7 @@ impl TypedExpr<GenType> {
             | TypedExpr::Unary(gt, ..)
             | TypedExpr::SubSeq(gt, ..)
             | TypedExpr::SubSeqInflate(gt, ..)
+            | TypedExpr::Append(gt, ..)
             | TypedExpr::FlatMap(gt, ..)
             | TypedExpr::FlatMapAccum(gt, ..)
             | TypedExpr::LeftFold(gt, ..)
@@ -974,6 +988,7 @@ mod __impls {
                     Expr::FlatMapList(rebox(lambda), vt, rebox(seq))
                 }
                 TypedExpr::Dup(_, count, x) => Expr::Dup(rebox(count), rebox(x)),
+                TypedExpr::Append(_, lhs, rhs) => Expr::Append(rebox(lhs), rebox(rhs)),
                 TypedExpr::EnumFromTo(_, start, stop) => {
                     Expr::EnumFromTo(rebox(start), rebox(stop))
                 }
@@ -1015,6 +1030,7 @@ mod __impls {
                     Format::UnionNondet(branches.into_iter().map(Format::from).collect())
                 }
                 TypedFormat::Tuple(_, elts) => Format::Tuple(revec(elts)),
+                TypedFormat::Sequence(_, elts) => Format::Sequence(revec(elts)),
                 TypedFormat::Repeat(_, inner) => Format::Repeat(rebox(inner)),
                 TypedFormat::Repeat1(_, inner) => Format::Repeat1(rebox(inner)),
                 TypedFormat::RepeatCount(_, count, inner) => {
diff --git a/src/decoder.rs b/src/decoder.rs
index 14f347c6..7a03541b 100644
--- a/src/decoder.rs
+++ b/src/decoder.rs
@@ -182,10 +182,6 @@ impl Value {
             .then_some(pattern_scope)
     }
 
-    fn collect_fields(fields: Vec<(Label, Self)>) -> Self {
-        Value::Record(fields)
-    }
-
     pub fn coerce_mapped_value(&self) -> &Self {
         match self {
             Value::Mapped(_orig, v) => v.coerce_mapped_value(),
@@ -711,6 +707,22 @@ impl Expr {
                     _ => panic!("SubSeqInflate: expected Seq"),
                 }
             }
+            Expr::Append(seq0, seq1) => {
+                match seq0.eval(scope).coerce_mapped_value().get_sequence() {
+                    Some(val_seq0) => match seq1.eval(scope).coerce_mapped_value().get_sequence() {
+                        Some(val_seq1) => {
+                            if val_seq0.is_empty() {
+                                return Cow::Owned(seq1.eval(scope).coerce_mapped_value().clone());
+                            } else if val_seq1.is_empty() {
+                                return Cow::Owned(seq0.eval(scope).coerce_mapped_value().clone());
+                            }
+                            Cow::Owned(Value::Seq(val_seq0.append(val_seq1)))
+                        }
+                        _ => unreachable!("Append: expected Seq in (lhs)"),
+                    },
+                    _ => unreachable!("Append: expected Seq in (lhs)"),
+                }
+            }
             Expr::FlatMap(expr, seq) => {
                 match seq.eval(scope).coerce_mapped_value().get_sequence() {
                     Some(values) => {
@@ -860,7 +872,7 @@ pub enum Decoder {
     Parallel(Vec<Decoder>),
     Branch(MatchTree, Vec<Decoder>),
     Tuple(Vec<Decoder>),
-    Record(Vec<(Label, Decoder)>),
+    Sequence(Vec<Decoder>),
     While(MatchTree, Box<Decoder>),
     Until(MatchTree, Box<Decoder>),
     RepeatCount(Box<Expr>, Box<Decoder>),
@@ -1013,7 +1025,7 @@ impl<'a> Compiler<'a> {
                 let mut decs = Vec::with_capacity(elems.len());
                 let mut fields = elems.iter();
                 while let Some(f) = fields.next() {
-                    let next = Rc::new(Next::Tuple(
+                    let next = Rc::new(Next::Sequence(
                         MaybeTyped::Untyped(fields.as_slice()),
                         next.clone(),
                     ));
@@ -1022,6 +1034,19 @@ impl<'a> Compiler<'a> {
                 }
                 Ok(Decoder::Tuple(decs))
             }
+            Format::Sequence(formats) => {
+                let mut decs = Vec::with_capacity(formats.len());
+                let mut fields = formats.iter();
+                while let Some(f) = fields.next() {
+                    let next = Rc::new(Next::Sequence(
+                        MaybeTyped::Untyped(fields.as_slice()),
+                        next.clone(),
+                    ));
+                    let df = self.compile_format(f, next)?;
+                    decs.push(df);
+                }
+                Ok(Decoder::Sequence(decs))
+            }
             Format::Repeat(a) => {
                 if a.is_nullable(self.module) {
                     return Err(anyhow!("cannot repeat nullable format: {a:?}"));
@@ -1306,15 +1331,6 @@ impl<'a> MultiScope<'a> {
         }
         self.parent.get_bindings(bindings);
     }
-
-    fn into_record(self) -> Value {
-        Value::collect_fields(
-            self.entries
-                .into_iter()
-                .map(|(name, value)| (name, value.into_owned()))
-                .collect(),
-        )
-    }
 }
 
 impl<'a> SingleScope<'a> {
@@ -1448,15 +1464,15 @@ impl Decoder {
                 }
                 Ok((Value::Tuple(v), input))
             }
-            Decoder::Record(fields) => {
+            Decoder::Sequence(decs) => {
                 let mut input = input;
-                let mut record_scope = MultiScope::with_capacity(scope, fields.len());
-                for (name, f) in fields {
-                    let (vf, next_input) = f.parse(program, &Scope::Multi(&record_scope), input)?;
-                    record_scope.push_owned(name.clone(), vf);
+                let mut v = Vec::with_capacity(decs.len());
+                for d in decs {
+                    let (vf, next_input) = d.parse(program, scope, input)?;
                     input = next_input;
+                    v.push(vf.clone());
                 }
-                Ok((record_scope.into_record(), input))
+                Ok((Value::Seq(SeqKind::Strict(v)), input))
             }
             Decoder::While(tree, a) => {
                 let mut input = input;
diff --git a/src/decoder/seq_kind.rs b/src/decoder/seq_kind.rs
index c7e4efe2..35293345 100644
--- a/src/decoder/seq_kind.rs
+++ b/src/decoder/seq_kind.rs
@@ -22,6 +22,23 @@ impl<'a, V: Clone> ValueSeq<'a, V> {
             ValueSeq::IntRange(r) => r.len(),
         }
     }
+
+    pub fn is_empty(&self) -> bool {
+        match self {
+            ValueSeq::ValueSeq(sk) => sk.is_empty(),
+            ValueSeq::IntRange(r) => r.is_empty(),
+        }
+    }
+
+    pub fn append(self, other: Self) -> SeqKind<V> {
+        if matches!(self, ValueSeq::IntRange(..)) | matches!(other, ValueSeq::IntRange(..)) {
+            unimplemented!("appending int ranges");
+        }
+        match (self, other) {
+            (ValueSeq::ValueSeq(v1), ValueSeq::ValueSeq(v2)) => (*v1).clone().append((*v2).clone()),
+            _ => unreachable!(),
+        }
+    }
 }
 
 pub(crate) fn sub_range(
@@ -139,6 +156,20 @@ impl<T: Clone> SeqKind<T> {
             SeqKind::Dup(n, v) => Iter::Dup(std::iter::repeat_n(Box::as_ref(v), *n)),
         }
     }
+
+    pub fn append(self, other: SeqKind<T>) -> SeqKind<T> {
+        if self.is_empty() {
+            other
+        } else if other.is_empty() {
+            self
+        } else {
+            // REVIEW - there may be minor optimizations we could leverage, but they would be very marginal yield
+            let mut seq0 = self.into_vec();
+            let mut seq1 = other.into_vec();
+            seq0.append(&mut seq1);
+            SeqKind::Strict(seq0)
+        }
+    }
 }
 
 impl<T: Clone> Index<usize> for SeqKind<T> {
diff --git a/src/helper.rs b/src/helper.rs
index c9b0356f..c1b21ed4 100644
--- a/src/helper.rs
+++ b/src/helper.rs
@@ -277,6 +277,11 @@ pub fn tuple(formats: impl IntoIterator<Item = Format>) -> Format {
     Format::Tuple(formats.into_iter().collect())
 }
 
+/// Helper-function for [`Format::Sequence`] that can take any iterable container of [`Format`]s.
+pub fn seq(formats: impl IntoIterator<Item = Format>) -> Format {
+    Format::Sequence(formats.into_iter().collect())
+}
+
 /// Helper-function for [`Format::Union`] over branches that are all [`Format::Variant`].
 ///
 /// Accepts any iterable container of tuples `(Name, Format)` for any `Name` that implements [`IntoLabel`].
@@ -566,11 +571,16 @@ pub fn not_byte(b: u8) -> Format {
     Format::Byte(!ByteSet::from([b]))
 }
 
-/// Returns a format that matches a given byte-sequence.
+/// Returns a format that matches a given byte-sequence and returns a tuple.
 pub fn is_bytes(bytes: &[u8]) -> Format {
     tuple(bytes.iter().copied().map(is_byte))
 }
 
+/// Returns a format that matches a given byte-sequence and returns an array/vector.
+pub fn byte_seq(bytes: &[u8]) -> Format {
+    seq(bytes.iter().copied().map(is_byte))
+}
+
 /// Helper const for a format that matches every byte.
 pub const ANY_BYTE: Format = Format::Byte(ByteSet::full());
 
diff --git a/src/lib.rs b/src/lib.rs
index 846098dc..653f998d 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -184,10 +184,13 @@ pub enum Expr {
     Dup(Box<Expr>, Box<Expr>),
 
     LiftOption(Option<Box<Expr>>),
+    /// [T] -> [T] -> [T] (append operation)
+    Append(Box<Expr>, Box<Expr>),
 }
 
 impl Expr {
     pub const UNIT: Self = Expr::Tuple(Vec::new());
+    pub const NIL: Self = Expr::Seq(Vec::new());
 
     pub fn record_proj(head: impl Into<Box<Expr>>, label: impl IntoLabel) -> Expr {
         let head: Box<Expr> = head.into();
@@ -538,6 +541,16 @@ impl Expr {
                 Some(expr) => Ok(ValueType::Option(Box::new(expr.infer_type(scope)?))),
                 None => Ok(ValueType::Option(Box::new(ValueType::Any))),
             },
+            Expr::Append(lhs, rhs) => {
+                let lhs_type = lhs.infer_type(scope)?;
+                let rhs_type = rhs.infer_type(scope)?;
+                if !matches!(lhs_type, ValueType::Seq(_)) {
+                    return Err(anyhow!("Append: lhs is not Seq: {lhs_type:?}"));
+                } else if !matches!(rhs_type, ValueType::Seq(_)) {
+                    return Err(anyhow!("Append: rhs is not Seq: {rhs_type:?}"));
+                }
+                Ok(ValueType::Seq(Box::new(lhs_type)))
+            }
         }
     }
 
@@ -554,7 +567,7 @@ impl Expr {
                     body.is_shadowed_by(name)
                 }
             }
-            Expr::Arith(_, x, y) | Expr::IntRel(_, x, y) => {
+            Expr::Arith(_, x, y) | Expr::IntRel(_, x, y) | Expr::Append(x, y) => {
                 x.is_shadowed_by(name) || y.is_shadowed_by(name)
             }
             Expr::Unary(_, x) => x.is_shadowed_by(name),
@@ -661,7 +674,6 @@ pub(crate) enum FieldLabel<Name> {
 }
 
 pub(crate) struct RecordFormat<'a> {
-    // First label is the
     flat: Vec<(FieldLabel<&'a Label>, &'a Format)>,
 }
 
@@ -840,6 +852,8 @@ pub enum Format {
     UnionNondet(Vec<Format>),
     /// Matches a sequence of concatenated formats
     Tuple(Vec<Format>),
+    /// Matches a fixed-length sequence of homogeneously-typed formats
+    Sequence(Vec<Format>),
     /// Repeat a format zero-or-more times
     Repeat(Box<Format>),
     /// Repeat a format one-or-more times
@@ -1024,6 +1038,14 @@ impl Format {
                 None => Bounds::exact(0),
                 Some(f) => f.match_bounds(module),
             },
+            Format::Sequence(fmts) => {
+                let mut total = Bounds::exact(0);
+                for fmt in fmts.iter() {
+                    let bounds = fmt.match_bounds(module);
+                    total = total + bounds;
+                }
+                total
+            }
         }
     }
 
@@ -1088,6 +1110,16 @@ impl Format {
                 None => Bounds::exact(0),
                 Some(f) => f.lookahead_bounds(module),
             },
+            Format::Sequence(fmts) => {
+                let mut sum_match = Bounds::exact(0);
+                let mut max_lookahead = Bounds::exact(0);
+                for fmt in fmts.iter() {
+                    max_lookahead =
+                        Bounds::union(max_lookahead, sum_match + fmt.lookahead_bounds(module));
+                    sum_match = sum_match + fmt.match_bounds(module);
+                }
+                max_lookahead
+            }
         }
     }
 
@@ -1110,17 +1142,16 @@ impl Format {
             Format::Union(branches) | Format::UnionNondet(branches) => {
                 Format::union_depends_on_next(branches, module)
             }
-            Format::Tuple(fields) => fields.iter().any(|f| f.depends_on_next(module)),
-            Format::Repeat(..) => true,
-            Format::Repeat1(..) => true,
-            Format::RepeatBetween(..) => true,
-            Format::RepeatCount(..) => false,
-            Format::RepeatUntilLast(..) => false,
-            Format::RepeatUntilSeq(..) => false,
+            Format::Tuple(fmts) | Format::Sequence(fmts) => {
+                fmts.iter().any(|f| f.depends_on_next(module))
+            }
+            Format::Repeat(..) | Format::Repeat1(..) | Format::RepeatBetween(..) => true,
+            Format::RepeatCount(..) | Format::RepeatUntilLast(..) | Format::RepeatUntilSeq(..) => {
+                false
+            }
             Format::AccumUntil(..) => false,
             Format::Maybe(..) => true,
-            Format::Peek(..) => false,
-            Format::PeekNot(..) => false,
+            Format::Peek(..) | Format::PeekNot(..) => false,
             Format::Slice(..) => false,
             Format::Bits(..) => false,
             Format::WithRelativeOffset(..) => false,
@@ -1345,7 +1376,13 @@ impl FormatModule {
                     other => Err(anyhow!("RepeatCount first argument type should be numeric, found {other:?} instead")),
                 }
             }
-
+            Format::Sequence(formats) => {
+                let mut elem_t = ValueType::Any;
+                for f in formats {
+                    elem_t = elem_t.unify(&self.infer_format_type(scope, f)?)?;
+                }
+                Ok(ValueType::Seq(Box::new(elem_t)))
+            }
             Format::RepeatBetween(min, max, a) => {
                 match min.infer_type(scope)? {
                     ref t0 @ ValueType::Base(b0) if b0.is_numeric() => {
@@ -1578,7 +1615,7 @@ enum Next<'a> {
     Empty,
     Union(Rc<Next<'a>>, Rc<Next<'a>>),
     Cat(MTFormatRef<'a>, Rc<Next<'a>>),
-    Tuple(MTFormatSlice<'a>, Rc<Next<'a>>),
+    Sequence(MTFormatSlice<'a>, Rc<Next<'a>>),
     Repeat(MTFormatRef<'a>, Rc<Next<'a>>),
     RepeatCount(usize, MTFormatRef<'a>, Rc<Next<'a>>),
     RepeatMax(usize, MTFormatRef<'a>, Rc<Next<'a>>), // dual to [RepeatCount] for 0..=N repeats
@@ -1719,8 +1756,8 @@ impl<'a> MatchTreeStep<'a> {
         self
     }
 
-    /// Constructs a [MatchTreeStep] that accepts a given tuple of sequential formats, with a trailing sequence of partially-consumed formats ([`Next`]s).
-    fn from_tuple(
+    /// Constructs a [MatchTreeStep] that accepts a given series of sequential formats, with a trailing sequence of partially-consumed formats ([`Next`]s).
+    fn from_sequential(
         module: &'a FormatModule,
         fields: &'a [Format],
         next: Rc<Next<'a>>,
@@ -1730,7 +1767,7 @@ impl<'a> MatchTreeStep<'a> {
             Some((f, fs)) => Self::from_format(
                 module,
                 f,
-                Rc::new(Next::Tuple(MaybeTyped::Untyped(fs), next)),
+                Rc::new(Next::Sequence(MaybeTyped::Untyped(fs), next)),
             ),
         }
     }
@@ -1833,7 +1870,7 @@ impl<'a> MatchTreeStep<'a> {
                 let next0: Rc<Next<'a>> = next.clone();
                 MatchTreeStep::<'a>::from_mt_format(module, *f, next0)
             }
-            Next::Tuple(fields, next) => {
+            Next::Sequence(fields, next) => {
                 let next = next.clone();
                 match fields {
                     MaybeTyped::Untyped(fields) => match fields.split_first() {
@@ -1841,7 +1878,7 @@ impl<'a> MatchTreeStep<'a> {
                         Some((f, fs)) => Self::from_format(
                             module,
                             f,
-                            Rc::new(Next::Tuple(MaybeTyped::Untyped(fs), next)),
+                            Rc::new(Next::Sequence(MaybeTyped::Untyped(fs), next)),
                         ),
                     },
                     MaybeTyped::Typed(fields) => match fields.split_first() {
@@ -1849,7 +1886,7 @@ impl<'a> MatchTreeStep<'a> {
                         Some((f, fs)) => Self::from_gt_format(
                             module,
                             f,
-                            Rc::new(Next::Tuple(MaybeTyped::Typed(fs), next)),
+                            Rc::new(Next::Sequence(MaybeTyped::Typed(fs), next)),
                         ),
                     },
                 }
@@ -1949,15 +1986,16 @@ impl<'a> MatchTreeStep<'a> {
                 }
                 tree
             }
-            TypedFormat::Tuple(_, fields) => match fields.split_first() {
-                None => Self::from_next(module, next),
-                Some((f, fs)) => Self::from_gt_format(
-                    module,
-                    f,
-                    Rc::new(Next::Tuple(MaybeTyped::Typed(fs), next)),
-                ),
-            },
-
+            TypedFormat::Sequence(_, fields) | TypedFormat::Tuple(_, fields) => {
+                match fields.split_first() {
+                    None => Self::from_next(module, next),
+                    Some((f, fs)) => Self::from_gt_format(
+                        module,
+                        f,
+                        Rc::new(Next::Sequence(MaybeTyped::Typed(fs), next)),
+                    ),
+                }
+            }
             TypedFormat::Repeat(_, a) => {
                 let tree = Self::from_next(module, next.clone());
                 tree.union(Self::from_gt_format(
@@ -2169,7 +2207,9 @@ impl<'a> MatchTreeStep<'a> {
                 }
                 tree
             }
-            Format::Tuple(fields) => Self::from_tuple(module, fields, next),
+            Format::Sequence(fields) | Format::Tuple(fields) => {
+                Self::from_sequential(module, fields, next)
+            }
             Format::Repeat(a) => {
                 let tree = Self::from_next(module, next.clone());
                 tree.union(Self::from_format(
diff --git a/src/loc_decoder.rs b/src/loc_decoder.rs
index b02c5c90..ba606adf 100644
--- a/src/loc_decoder.rs
+++ b/src/loc_decoder.rs
@@ -972,6 +972,31 @@ impl Expr {
                     _ => panic!("SubSeqInflate: expected Seq"),
                 }
             }
+            Expr::Append(seq0, seq1) => {
+                let tmp0 = seq0.eval_with_loc(scope);
+                let val0 = tmp0.coerce_mapped_value();
+                match val0.get_sequence() {
+                    Some(val_seq0) => {
+                        let tmp1 = seq1.eval_with_loc(scope);
+                        let val1 = tmp1.coerce_mapped_value();
+                        match val1.get_sequence() {
+                            Some(val_seq1) => {
+                                if val_seq0.is_empty() {
+                                    return Cow::Owned(val1.clone());
+                                } else if val_seq1.is_empty() {
+                                    return Cow::Owned(val0.clone());
+                                }
+                                Cow::Owned(ParsedValue::Seq(Parsed {
+                                    loc: ParseLoc::Synthesized,
+                                    inner: val_seq0.append(val_seq1),
+                                }))
+                            }
+                            _ => unreachable!("Append: expected Seq in (lhs)"),
+                        }
+                    }
+                    _ => unreachable!("Append: expected Seq in (lhs)"),
+                }
+            }
             Expr::FlatMap(expr, seq) => {
                 match seq
                     .eval_with_loc(scope)
@@ -1235,10 +1260,6 @@ impl<'a> LocMultiScope<'a> {
         }
         self.parent.get_bindings(bindings);
     }
-
-    fn into_record(self) -> ParsedValue {
-        ParsedValue::collect_fields(self.entries)
-    }
 }
 
 impl<'a> LocSingleScope<'a> {
@@ -1416,16 +1437,16 @@ impl Decoder {
                 let total_len = input.offset - start_offset;
                 Ok((ParsedValue::new_tuple(v, start_offset, total_len), input))
             }
-            Decoder::Record(fields) => {
+            Decoder::Sequence(fields) => {
                 let mut input = input;
-                let mut record_scope = LocMultiScope::with_capacity(scope, fields.len());
-                for (name, f) in fields {
-                    let (vf, next_input) =
-                        f.parse_with_loc(program, &LocScope::Multi(&record_scope), input)?;
-                    record_scope.push(name.clone(), vf);
+                let mut v = Vec::with_capacity(fields.len());
+                for f in fields {
+                    let (vf, next_input) = f.parse_with_loc(program, scope, input)?;
                     input = next_input;
+                    v.push(vf.clone());
                 }
-                Ok((record_scope.into_record(), input))
+                let total_len = input.offset - start_offset;
+                Ok((ParsedValue::new_seq(v, start_offset, total_len), input))
             }
             Decoder::While(tree, a) => {
                 let mut input = input;
diff --git a/src/output/flat.rs b/src/output/flat.rs
index cd4ba999..0bd8fedf 100644
--- a/src/output/flat.rs
+++ b/src/output/flat.rs
@@ -143,7 +143,7 @@ fn check_covered(
                 check_covered(module, path, format)?;
             }
         }
-        Format::Tuple(formats) => {
+        Format::Tuple(formats) | Format::Sequence(formats) => {
             for format in formats {
                 check_covered(module, path, format)?;
             }
@@ -259,6 +259,16 @@ impl<'module, W: io::Write> Context<'module, W> {
                 }
                 _ => panic!("expected tuple, found {value:?}"),
             },
+            Format::Sequence(formats) => match value {
+                Value::Seq(seq_kind) => {
+                    for (index, value) in seq_kind.iter().enumerate() {
+                        let format = &formats[index];
+                        self.write_flat(value, format)?;
+                    }
+                    Ok(())
+                }
+                _ => panic!("expected sequence, found {value:?}"),
+            },
             Format::Repeat(format)
             | Format::Repeat1(format)
             | Format::ForEach(_, _, format)
diff --git a/src/output/tree.rs b/src/output/tree.rs
index 969b63d9..e26161dd 100644
--- a/src/output/tree.rs
+++ b/src/output/tree.rs
@@ -359,7 +359,7 @@ impl<'module> TreePrinter<'module> {
             },
             Format::Tuple(formats) => match value {
                 ParsedValue::Tuple(parsed_tuple) => {
-                    if self.flags.pretty_ascii_strings && self.is_ascii_tuple_format(formats) {
+                    if self.flags.pretty_ascii_strings && self.are_all_ascii_formats(formats) {
                         self.compile_parsed_ascii_seq(parsed_tuple)
                     } else {
                         self.compile_parsed_tuple(parsed_tuple, Some(formats))
@@ -367,6 +367,16 @@ impl<'module> TreePrinter<'module> {
                 }
                 _ => panic!("expected tuple, found {value:?}"),
             },
+            Format::Sequence(formats) => match value {
+                ParsedValue::Seq(parsed_seq) => {
+                    if self.flags.pretty_ascii_strings && self.are_all_ascii_formats(formats) {
+                        self.compile_parsed_ascii_seq(parsed_seq)
+                    } else {
+                        self.compile_parsed_seq_formats(parsed_seq, Some(formats.as_slice()))
+                    }
+                }
+                _ => panic!("expected sequence, found {value:?}"),
+            },
             Format::Repeat(format)
             | Format::Repeat1(format)
             | Format::ForEach(_, _, format)
@@ -525,7 +535,7 @@ impl<'module> TreePrinter<'module> {
             },
             Format::Tuple(formats) => match value {
                 Value::Tuple(values) => {
-                    if self.flags.pretty_ascii_strings && self.is_ascii_tuple_format(formats) {
+                    if self.flags.pretty_ascii_strings && self.are_all_ascii_formats(formats) {
                         self.compile_ascii_seq(values)
                     } else {
                         self.compile_tuple(values, Some(formats))
@@ -533,6 +543,16 @@ impl<'module> TreePrinter<'module> {
                 }
                 _ => panic!("expected tuple, found {value}"),
             },
+            Format::Sequence(formats) => match value {
+                Value::Seq(values) => {
+                    if self.flags.pretty_ascii_strings && self.are_all_ascii_formats(formats) {
+                        self.compile_ascii_seq(values)
+                    } else {
+                        self.compile_seq_formats(values, Some(formats.as_slice()))
+                    }
+                }
+                _ => panic!("expected sequence, found {value}"),
+            },
             Format::LiftedOption(fmt) => match value {
                 Value::Option(opt_val) => match (fmt, opt_val) {
                     (None, None) => Fragment::string("none"),
@@ -651,10 +671,9 @@ impl<'module> TreePrinter<'module> {
         }
     }
 
-    fn is_ascii_tuple_format(&self, formats: &[Format]) -> bool {
+    fn are_all_ascii_formats(&self, formats: &[Format]) -> bool {
         !formats.is_empty() && formats.iter().all(|f| f.is_ascii_char_format(self.module))
     }
-
     pub fn compile_value(&mut self, value: &Value) -> Fragment {
         match value {
             Value::Bool(true) => Fragment::string("true"),
@@ -900,6 +919,41 @@ impl<'module> TreePrinter<'module> {
         }
     }
 
+    fn compile_seq_formats(
+        &mut self,
+        vals: &SeqKind<Value>,
+        formats: Option<&[Format]>,
+    ) -> Fragment {
+        if vals.is_empty() {
+            Fragment::String("[]".into())
+        } else {
+            let mut frag = Fragment::new();
+            let last_index = vals.len() - 1;
+            let (upper_bound, any_skipped) = match self.preview_len {
+                Some(preview_len) if vals.len() > preview_len => {
+                    (preview_len, preview_len != last_index)
+                }
+                Some(_) | None => (last_index, false),
+            };
+            for index in 0..upper_bound {
+                let val = &vals[index];
+                let format = formats.map(|fs| &fs[index]);
+                frag.append(self.compile_field_value_continue(index, val, format, false));
+            }
+            if any_skipped {
+                frag.append(self.compile_field_skipped());
+            }
+            let format = formats.map(|fs| &fs[last_index]);
+            frag.append(self.compile_field_value_last(
+                last_index,
+                &vals[last_index],
+                format,
+                false,
+            ));
+            frag
+        }
+    }
+
     fn compile_parsed_tuple(
         &mut self,
         vals: &Parsed<Vec<ParsedValue>>,
@@ -966,6 +1020,42 @@ impl<'module> TreePrinter<'module> {
         }
     }
 
+    fn compile_parsed_seq_formats(
+        &mut self,
+        vals: &Parsed<SeqKind<ParsedValue>>,
+        formats: Option<&[Format]>,
+    ) -> Fragment {
+        let Parsed { inner, .. } = vals;
+        if inner.is_empty() {
+            Fragment::String("[]".into())
+        } else {
+            let mut frag = Fragment::new();
+            let last_index = inner.len() - 1;
+            let (upper_bound, any_skipped) = match self.preview_len {
+                Some(preview_len) if inner.len() > preview_len => {
+                    (preview_len, preview_len != last_index)
+                }
+                Some(_) | None => (last_index, false),
+            };
+            for ix in 0..upper_bound {
+                let val = &inner[ix];
+                let format = formats.map(|fs| &fs[ix]);
+                frag.append(self.compile_parsed_field_value_continue(ix, val, format, false));
+            }
+            if any_skipped {
+                frag.append(self.compile_field_skipped());
+            }
+            let format = formats.map(|fs| &fs[last_index]);
+            frag.append(self.compile_parsed_field_value_last(
+                last_index,
+                &inner[last_index],
+                format,
+                false,
+            ));
+            frag
+        }
+    }
+
     fn compile_seq(&mut self, vals: &SeqKind<Value>, format: Option<&Format>) -> Fragment {
         if vals.is_empty() {
             Fragment::String("[]".into())
@@ -1708,6 +1798,11 @@ impl<'module> TreePrinter<'module> {
                 prec,
                 Precedence::BIT_SHIFT,
             ),
+            Expr::Append(lhs, rhs) => cond_paren(
+                self.binary_op(" ++ ", lhs, rhs, Precedence::APPEND, Precedence::APPEND),
+                prec,
+                Precedence::APPEND,
+            ),
             Expr::Unary(UnaryOp::BoolNot, expr) => cond_paren(
                 self.prefix_op("!", None, expr),
                 prec,
@@ -2197,6 +2292,9 @@ impl<'module> TreePrinter<'module> {
             Format::Tuple(formats) if formats.is_empty() => Fragment::String("()".into()),
             Format::Tuple(_) => Fragment::String("(...)".into()),
 
+            Format::Sequence(formats) if formats.is_empty() => Fragment::String("[]".into()),
+            Format::Sequence(_) => Fragment::String("[ ... ]".into()),
+
             Format::Hint(StyleHint::Record { old_style: true }, inner) => match inner.as_ref() {
                 Format::Compute(expr) if matches!(&**expr, Expr::Record(vs) if vs.is_empty()) => {
                     Fragment::String("{}".into())
diff --git a/src/precedence.rs b/src/precedence.rs
index ca23b37f..05728551 100644
--- a/src/precedence.rs
+++ b/src/precedence.rs
@@ -221,6 +221,9 @@ impl Precedence {
 
     pub(crate) const FORMAT_COMPOUND: Self = Self::Top;
 
+    // REVIEW - does list-append need its own precedence or is this good enough?
+    pub(crate) const APPEND: Self = Precedence::ArithInfix(ArithLevel::AddSub);
+
     pub(crate) fn bump_format(&self) -> Self {
         match self {
             Precedence::Top => Precedence::Atomic,
diff --git a/src/prelude.rs b/src/prelude.rs
index f6ffef5e..d9b51005 100644
--- a/src/prelude.rs
+++ b/src/prelude.rs
@@ -81,6 +81,17 @@ where
     Ok(res)
 }
 
+/// Joins two slices into a single vector via iterator chaining, returning the result
+pub fn seq_append<T, S>(lhs: impl AsRef<S>, rhs: impl AsRef<S>) -> Vec<T>
+where
+    T: Clone,
+    for<'a> &'a S: IntoIterator<Item = &'a T>,
+{
+    let lhs_iter = lhs.as_ref().into_iter().cloned();
+    let rhs_iter = rhs.as_ref().into_iter().cloned();
+    Iterator::chain(lhs_iter, rhs_iter).collect()
+}
+
 /// Performs a fold/reduce-style operation on a given list, starting from an initial accumulator value
 /// and replacing it with the evaluation of `f(accum, elem)` for each element in the iterator, in order.
 ///
diff --git a/src/typecheck.rs b/src/typecheck.rs
index b6167d62..6ac7f1da 100644
--- a/src/typecheck.rs
+++ b/src/typecheck.rs
@@ -2141,6 +2141,19 @@ impl TypeChecker {
 
                 newvar
             }
+            Expr::Append(seq0, seq1) => {
+                let newvar = self.get_new_uvar();
+                let seq0_var = self.infer_var_expr(seq0.as_ref(), scope)?;
+                let seq1_var = self.infer_var_expr(seq1.as_ref(), scope)?;
+
+                let elem_var = self.get_new_uvar();
+
+                self.unify_var_pair(seq0_var, seq1_var)?;
+                self.unify_var_proj_elem(seq0_var, elem_var)?;
+                self.unify_var_proj_elem(newvar, elem_var)?;
+
+                newvar
+            }
             Expr::FlatMap(f_expr, seq_expr) => {
                 let newvar = self.get_new_uvar();
 
@@ -2742,6 +2755,16 @@ impl TypeChecker {
                 self.unify_var_utype(newvar, Rc::new(UType::Tuple(uts)))?;
                 Ok(newvar)
             }
+            Format::Sequence(ts) => {
+                let newvar = self.get_new_uvar();
+                let elem_v = self.get_new_uvar();
+                for t in ts {
+                    let v = self.infer_var_format(t, ctxt)?;
+                    self.unify_var_pair(elem_v, v)?;
+                }
+                self.unify_var_utype(newvar, Rc::new(UType::Seq(Rc::new(UType::Var(elem_v)))))?;
+                Ok(newvar)
+            }
             Format::Repeat(inner) | Format::Repeat1(inner) => {
                 let newvar = self.get_new_uvar();
                 let t = self.infer_utype_format(inner, ctxt)?;

From b066aae47ce3e78efe5f22680b407a539ad14c7a Mon Sep 17 00:00:00 2001
From: Peter Duchovni <caufeminecraft+github@gmail.com>
Date: Fri, 16 May 2025 17:34:24 +1000
Subject: [PATCH 2/4] Update test code and expect-file for png

---
 src/codegen/mod.rs                    | 2 +-
 src/codegen/rust_ast/mod.rs           | 4 ++--
 tests/expected/decode/test.png.stdout | 9 +++++++++
 3 files changed, 12 insertions(+), 3 deletions(-)

diff --git a/src/codegen/mod.rs b/src/codegen/mod.rs
index 57de1e08..a81c0c17 100644
--- a/src/codegen/mod.rs
+++ b/src/codegen/mod.rs
@@ -5114,7 +5114,7 @@ mod tests {
                 "{}",
                 lambda
                     .apply_pair(
-                        RustExpr::CloneOf(Box::new(RustExpr::local("acc"))),
+                        RustExpr::Owned(OwnedRustExpr { expr: Box::new(RustExpr::local("acc")), kind: OwnedKind::Cloned }),
                         RustExpr::local("seq"),
                         ExprInfo::default()
                     )
diff --git a/src/codegen/rust_ast/mod.rs b/src/codegen/rust_ast/mod.rs
index 396889b4..f8192c50 100644
--- a/src/codegen/rust_ast/mod.rs
+++ b/src/codegen/rust_ast/mod.rs
@@ -1345,8 +1345,8 @@ impl ToFragment for StructExpr {
 
 #[derive(Debug, Clone)]
 pub(crate) struct OwnedRustExpr {
-    expr: Box<RustExpr>,
-    kind: OwnedKind,
+    pub expr: Box<RustExpr>,
+    pub kind: OwnedKind,
 }
 
 #[derive(Debug, Clone)]
diff --git a/tests/expected/decode/test.png.stdout b/tests/expected/decode/test.png.stdout
index 2593ca6f..d60a577c 100644
--- a/tests/expected/decode/test.png.stdout
+++ b/tests/expected/decode/test.png.stdout
@@ -1,5 +1,14 @@
 └── data <- _ |...| _ :=
     └── png <- png.main :=
+        ├── signature <- [ ... ] :=
+        │   ├── 0
+        │   ├── 1
+        │   ├── 2
+        │   ├── 3
+        │   ├── 4
+        │   ├── 5
+        │   ├── 6
+        │   └── 7
         ├── ihdr <- png.ihdr :=
         │   ├── length <- assert (length -> length <= 2147483647) base.u32be := 13
         │   ├── tag <- png.ihdr-tag

From 4ddc298643d7500e6d8d3bc101ee30a140e6fff7 Mon Sep 17 00:00:00 2001
From: Peter Duchovni <caufeminecraft+github@gmail.com>
Date: Thu, 15 May 2025 16:30:22 +1000
Subject: [PATCH 3/4] Daedalus notes and pdf prototype

---
 Cargo.lock                         |   8 +
 Cargo.toml                         |   2 +-
 Daedalus.md                        | 269 +++++++++++++++++++++++++++++
 experiments/doodle-pdf/Cargo.toml  |   8 +
 experiments/doodle-pdf/src/main.rs |   5 +
 experiments/doodle-pdf/src/pdf.rs  |  99 +++++++++++
 6 files changed, 390 insertions(+), 1 deletion(-)
 create mode 100644 Daedalus.md
 create mode 100644 experiments/doodle-pdf/Cargo.toml
 create mode 100644 experiments/doodle-pdf/src/main.rs
 create mode 100644 experiments/doodle-pdf/src/pdf.rs

diff --git a/Cargo.lock b/Cargo.lock
index d34974e3..1a691416 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -388,6 +388,14 @@ dependencies = [
  "serde_json",
 ]
 
+[[package]]
+name = "doodle-pdf"
+version = "0.1.0"
+dependencies = [
+ "doodle",
+ "doodle-formats",
+]
+
 [[package]]
 name = "doodle_gencode"
 version = "0.1.0"
diff --git a/Cargo.toml b/Cargo.toml
index dc36b8c2..0be0d22f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,5 +1,5 @@
 [workspace]
-members = [".", "generated/", "doodle-formats/"]
+members = [".", "generated/", "doodle-formats/", "experiments/doodle-pdf"]
 
 [package]
 name = "doodle"
diff --git a/Daedalus.md b/Daedalus.md
new file mode 100644
index 00000000..3bb6241b
--- /dev/null
+++ b/Daedalus.md
@@ -0,0 +1,269 @@
+# Daedalus Notes
+
+## 3.1 (Primitive Parsers)
+
+* `^<value>` is achievable through `compute`
+* `Fail <msg>` requires a refactor we have discussed but never implemented
+  * This could be a modification of `Fail` itself, or a wrapper using `StyleHint`
+* We don't have a notion of character classes for the parser `$[c]`, but we could emulate this with `ByteSet` constants
+* The closest thing to `Match <string>` is `is_bytes`, which stores an N-Tuple ([issue #260](https://github.com/yeslogic/doodle/issues/260) discusses this)
+
+## 3.2 (Sequential Composition)
+
+The syntax `{ P1; ...; Pn }` can be emulated with `LetFormat`/`MonadSeq`.
+
+
+### Example Translations
+
+```ddl
+def Add2 =
+  block
+    let x = BEUInt64
+    let y = BEUInt64
+    ^ x + y
+
+def StatementSemi =
+  block
+    $$ = Statement
+    $[';']
+```
+
+```rust
+let add2 =
+    chain(
+        base.u64be(), "x",
+        chain(
+            base.u64be(),
+            "y",
+            compute(add(var("x"), var("y")))
+        )
+    );
+
+let statement_semi =
+    chain(
+        statement, // defined elsewhere,
+        "ret",
+        monad_seq(
+            is_byte(b';'),
+            compute(var("ret"))
+        )
+    );
+```
+
+## 3.3 (Parallel Composition)
+
+There is currently no way of performing *unbiased* composition in `doodle`; all parallel compositions
+are first-come-first-served and will bias towards the first non-error result.
+
+`<|` is therefore supported, while `|` is not.
+
+## 3.4 (Repetition)
+
+* Kleene Star - `Many <P>` is just `Repeat`, while `Many (1..) <P>` is `Repeat`
+* Kleene Star with State - At least some cases of `many (x = s) <P>` can be emulated with `Map(Repeat, LeftFold)`, while `AccumUntil` might be usable in other cases; there may be cases where neither are applicable, in which case a more bespoke `Format` may be required.
+* `map (k,v in c) <P>` and `for (x = s; k,v in c) <P>` could be emulated with `ForEach`, at least in certain instances.
+
+## 3.5 (Branching)
+
+* `case-of` (and, by extension, `if-then-else`) appear one-to-one with `Match`
+
+## 3.6 (Coercions)
+
+* There are no format-level types per-se, but various `Expr`s like `AsU64` and family accomplish much-the-same, albeit in a closed class rather with a constructive syntax.
+  * `as?` (dynamic safe coercion) is closest to what we have, since `AsU{8,16,32,64}`/`AsChar` are runtime-checked; we currently have nothing of the sort of `as` (static safe) or `as!` (static lossy) coercion
+
+## 5.1 (Bitdata)
+
+Through helpers like `bit_fields_u8` and so forth, which can be defined as-needed, we have a plausible
+analogue to the `bitdata` declarations in Daedalus.
+
+However, the current implementation of `BitFieldKind` is somewhat restrictive, in the following ways, compared to `bitdata`:
+
+* It does not support type-coercions (e.g. u8 packed in a u16)
+* It does not support fixed-bits checking other than all-zero
+
+These are features that could be added with various caveats, if necessary.
+
+### Examples
+
+```ddl
+bitdata Packed where
+  x: uint 8
+  0xFFFF
+  y: uint 8
+
+bitdata Uni where
+  value = { get: Packed }
+  null  = 0
+```
+
+```rust
+use doodle::helper::BitFieldKind::*;
+
+let packed = bit_fields_u32([ // <- this is not yet defined
+    BitsField { field_name: "x", bit_width: 8 },
+    Reserved { bit_width: 16, check_zero: false },
+    BitsField { field_name: "y", bit_width: 8 },
+]);
+
+let uni = union_nondet([
+    ("null", is_bytes(&[0; 4])),
+    ("value", packed),
+]);
+```
+
+This is more of a parse-level directive than a data-type declaration, however,
+as while in Daedalus the two are implicitly specified with the same declaration,
+in `doodle` the data-type is a synthetic implication of the parse declaration,
+and cannot be used in coercions; for that, we would need a separate declaration
+of a dependent `u32 -?-> Packed` computation that could then be fed in arbitrary
+arguments to interpret as `Packed`.
+
+```rust
+use doodle::helper::BitFieldKind::*;
+let as_packed = module.define_format_args(
+    "Packed-Coerce",
+    [(Label::Borrowed("raw"), ValueType::Base(BaseType::U32))],
+    cast_u32_bit_fields( // <- also not defined, but furthermore has no archetype
+        var("raw"),
+        [
+            BitsField { field_name: "x", bit_width: 8 },
+            Reserved { bit_width: 16, check_zero: false },
+            BitsField { field_name: "y", bit_width: 8 },
+        ]
+    )
+);
+```
+
+## 5.2 (Automatic ADT Synthesis)
+
+We have no first-class types in the specification language of `doodle`, and all
+types are implied through synthesis over the declared formats and expressions.
+As a result, type-ascriptions are syntactically unavailable.
+
+Even currently, we can still at least ensure that two parsers have mutually
+compatible types, by defining a declaration-check marker-format that we run
+through type-checking but discard afterwards:
+
+```rust
+let point = module.define_format("types.point", record([("x", base.u8()), ("y", base.u8())]));
+let point_x = module.define_format("types.point_x", record([("x", base.u8()), ("y", is_byte(0))]));
+
+let __type_proof = module.define_format(
+    "__TYPE_PROOF",
+    monad_seq(
+        union([point.call(), point_x.call()]),
+        /* we can sequence other type-compatibility assertion-formats here as well */
+        Format::EMPTY,
+    )
+);
+```
+
+Because every format needs a reified type for the module to be usable, but these
+type-ascriptions need not be a bijection, there would be no implicitly-defined
+alias `type PointX = Point` as would be synthesized by the corresponding
+Daedalus declarations; instead, whichever type-name is preferred would win, and
+both formats would receive verbatim-identical type-ascriptions.
+
+
+
+While tagged unions in general are supportable, the example given for tagged
+unions cannot be constructed in `doodle` because of a lack of support for
+auto-recursive and mutually-recursive format-constructs. Implementing these is
+not *a priori* impossible, but would require a noticeable investment of effort
+into a design to support this, which would most notably require a
+termination-rule for otherwise infinitely-recursive type-checking.
+
+## 6 (Lookahead and Stream Manipulation)
+
+The concept of a `Stream` is not first-class within the `Format` model of `doodle`,
+though there are various combinators that interact with it.
+
+* `GetStream` does not obviously have a one-to-one equivalent in `doodle`, though constructs that use it may be replicable in other ways
+* `Drop n s` does not properly exist as a first-class construction but can be emulated with some degree of ingenuity
+* `Take n s` itself is not quite analogous to anything in `doodle`
+* `SetStream` does not properly exist as a first-class construction but can be emulated with some degree of ingenuity
+* `Chunk n P` is equivalent to `Slice`
+* `Lookahead P` is equivalent to `Peek`
+* `WithStream` can be emulated using `DecodeBytes` up to a certain degree, where if the parser itself is responsible for determining where the stream ends, there may be issues in capturing the stream into a suitable buffer.
+
+### Example
+
+```ddl
+block
+  let base = GetStream
+  Many block
+    let offset = Word64
+    let here = GetStream
+    SetStream (Drop offset base)
+    $$ = ParseObject
+    SetStream here
+```
+
+```rust
+chain(
+    Format::Pos,
+    "base",
+    repeat(
+        chain(base.u64be(), "offset",
+            with_relative_offset(Some(var("base")), var("offset"), parse_object)
+        )
+    )
+)
+```
+
+## 7 (Eager vs. Lazy)
+
+There is currently no support, at any layer, for parse-level laziness in the
+`doodle` processing model; there is some value-level laziness involving
+constructed sequences, but that is more of an representation-level optimization
+than a feature of the processing model, and aside from performance concerns,
+nothing would change if it were eliminated.
+
+Multiple paths cannot be explored in parallel, both for unbounded/indefinite-length
+repetitions as well as for more explicit alternations over N branches. There are currently only two places where nondeterministic unions are used:
+
+* At the top-level, for alternating between distinct data-formats (e.g. png, OpenType, gzip); and secondly, to allow fallback to uninterpreted bytes during speculative
+parsing of zlib-compressed UTF-8 in an `iTXt` PNG-chunk.
+
+The latter usage is more of a band-aid against unwanted parse-failure, and due
+to the limitations of the error-propagation model whereby high-confidence
+partial-parses of a given top-format are nevertheless rejected altogether when
+even a single, possibly trivial component encounters uncaught parse-failure.
+Aside from mitigation within the operational model that would allow
+determinations such as 'correct format, malformed data', there are ways to get
+around this locally without adjusting the model, by using a separate construct
+from `UnionNondet` to avoid coupling one form of speculative parsing to the only
+version of something like that in the current implementation of `doodle`:
+
+```rust
+fn try_with_fallback(f0: Format, f1: Format) -> Format {
+    TryWithFallback(Box::new(f0), Box::new(f1))
+}
+
+/* .. */
+
+let zlib_utf8txt_or_raw =
+    try_with_fallback(
+        fmt_variant("valid", zlib_utf8text),
+        fmt_variant("invalid", repeat(base.u8())),
+    );
+```
+
+This can be used in a broader sense, as a more generic 'permit local failure gracefully'
+construct:
+
+```rust
+fn permit_fail(f: Format, dummy: Expr) -> Format {
+    TryWithFallback(Box::new(f), Box::new(compute(dummy)))
+}
+
+// vvv Usage Patterns vvv
+fn opt_success(f: Format) -> Format {
+    permit_fail(fmt_some(f), expr_none())
+}
+
+fn try_or_invalid(f: Format) -> Format {
+    permit_fail(fmt_variant("valid", f), Expr::Variant("invalid".into(), Expr::UNIT))
+}
+```
diff --git a/experiments/doodle-pdf/Cargo.toml b/experiments/doodle-pdf/Cargo.toml
new file mode 100644
index 00000000..87e700b0
--- /dev/null
+++ b/experiments/doodle-pdf/Cargo.toml
@@ -0,0 +1,8 @@
+[package]
+name = "doodle-pdf"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+doodle = { path = "../../" }
+doodle-formats = { path = "../../doodle-formats/" }
diff --git a/experiments/doodle-pdf/src/main.rs b/experiments/doodle-pdf/src/main.rs
new file mode 100644
index 00000000..701b2a50
--- /dev/null
+++ b/experiments/doodle-pdf/src/main.rs
@@ -0,0 +1,5 @@
+mod pdf;
+
+fn main() {
+    println!("Hello, world!");
+}
diff --git a/experiments/doodle-pdf/src/pdf.rs b/experiments/doodle-pdf/src/pdf.rs
new file mode 100644
index 00000000..377ad233
--- /dev/null
+++ b/experiments/doodle-pdf/src/pdf.rs
@@ -0,0 +1,99 @@
+use doodle::{helper::*, prelude::ByteSet, Expr, Format, FormatModule, FormatRef};
+use doodle_formats::format::base::BaseModule;
+
+/// Greedily matches the given format, skipping any bytes that don't match.
+fn skip_to(f: Format) -> Format {
+    // FIXME - we need a combinator for this to avoid infinite recursion while constructing the Format
+    Format::UnionNondet(vec![
+        f.clone(),
+        monad_seq(Format::ANY_BYTE, skip_to(f)),
+    ])
+}
+
+fn only(f: Format) -> Format {
+    chain(f, "val", monad_seq(Format::EndOfInput, compute(var("val"))))
+}
+
+/// Runs a parser and discards its value, returning `Format::EMPTY`
+fn void(f: Format) -> Format {
+    monad_seq(f, Format::EMPTY)
+}
+
+/// Matches a string (as bytes) exactly, and returns it as a Seq(u8)
+fn match_str(bytes: &[u8]) -> Format {
+    todo!()
+}
+
+pub fn main(module: &mut FormatModule, base: &BaseModule) -> FormatRef {
+    let simple_ws: ByteSet = ByteSet::from([0x00, 0x09, 0x0C, 0x20]);
+    let ascii_lf: u8 = 0x0A;
+    let ascii_cr: u8 = 0x0D;
+
+    let inline_char = Format::Byte(ByteSet::from([ascii_lf, ascii_cr]).complement());
+
+
+    let simple_eol = module.define_format("pdf.util.simple_eol",
+        Format::UnionNondet(vec![
+            void(is_bytes(&[ascii_cr, ascii_lf])),
+            void(is_byte(ascii_lf)),
+        ])
+    );
+
+    let eol = module.define_format(
+        "pdf.util.eol",
+        Format::UnionNondet(vec![
+            simple_eol.call(),
+            void(is_byte(ascii_cr)),
+        ])
+    );
+
+    let comment = module.define_format(
+        "pdf.util.comment",
+        monad_seq(
+            is_byte(b'%'),
+            monad_seq(
+                repeat(inline_char),
+                eol.call()
+            )
+        )
+    );
+
+    let any_ws = module.define_format("pdf.util.any_ws",
+        Format::UnionNondet(vec![
+            void(byte_in(simple_ws)), // $simpleWS
+            comment.call(), // Comment
+            eol.call(), // EOL
+        ])
+    );
+
+    let token = |f: Format| {
+        chain(f, "tok", monad_seq(repeat(any_ws.call()), compute(var("tok"))))
+    };
+
+    let unsigned_lead_digits = todo!();
+
+    // TODO - add support to allow de-stringification of numbers
+    let unsigned_number = module.define_format("pdf.util.unsigned_number",
+        Format::UnionNondet(vec![
+            unsigned_lead_digits.call(),
+            monad_seq(is_byte(b'.'), todo!()),
+        ])
+    );
+    // TODO: add support to allow de-stringification of numbers
+    let number = module.define_format("pdf.util.number", union([
+        monad_seq(is_byte(b'-'), map(unsigned_number.call(), lambda("digits", concat(Expr::Seq(vec![Expr::Seq(vec![as_char(Expr::U8(b'-'))]), var("digits")]))))),
+        monad_seq(optional(is_byte(b'+')), unsigned_number.call()),
+    ]));
+
+    let pdf_chunk = todo!();
+
+    module.define_format("pdf.main",
+        only(
+            record_auto([
+                ("version", skip_to(monad_seq(is_bytes(b"%PDF-"), number.call()))),
+                ("chunks", repeat(pdf_chunk.call())),
+                ("__rem", repeat(any_ws.call())),
+            ])
+        )
+    )
+}

From 641cdb6fbc5eb9dfc118e0ff6829de98cd89308c Mon Sep 17 00:00:00 2001
From: Peter Duchovni <caufeminecraft+github@gmail.com>
Date: Mon, 19 May 2025 15:16:28 +1000
Subject: [PATCH 4/4] implement more of the pdf outline

---
 Daedalus.md                       |   3 -
 experiments/doodle-pdf/src/pdf.rs | 362 +++++++++++++++++++++++++-----
 src/codegen/mod.rs                |   5 +-
 src/helper.rs                     | 106 +++++++--
 src/lib.rs                        |  37 +++
 5 files changed, 436 insertions(+), 77 deletions(-)

diff --git a/Daedalus.md b/Daedalus.md
index 3bb6241b..121ec194 100644
--- a/Daedalus.md
+++ b/Daedalus.md
@@ -12,7 +12,6 @@
 
 The syntax `{ P1; ...; Pn }` can be emulated with `LetFormat`/`MonadSeq`.
 
-
 ### Example Translations
 
 ```ddl
@@ -165,8 +164,6 @@ alias `type PointX = Point` as would be synthesized by the corresponding
 Daedalus declarations; instead, whichever type-name is preferred would win, and
 both formats would receive verbatim-identical type-ascriptions.
 
-
-
 While tagged unions in general are supportable, the example given for tagged
 unions cannot be constructed in `doodle` because of a lack of support for
 auto-recursive and mutually-recursive format-constructs. Implementing these is
diff --git a/experiments/doodle-pdf/src/pdf.rs b/experiments/doodle-pdf/src/pdf.rs
index 377ad233..4f9bf934 100644
--- a/experiments/doodle-pdf/src/pdf.rs
+++ b/experiments/doodle-pdf/src/pdf.rs
@@ -1,15 +1,92 @@
-use doodle::{helper::*, prelude::ByteSet, Expr, Format, FormatModule, FormatRef};
+use std::ops::Range;
+
+use doodle::{
+    BaseType, Expr, Format, FormatModule, FormatRef, IntoLabel, Label, Pattern, ValueType,
+    helper::*, prelude::ByteSet,
+};
 use doodle_formats::format::base::BaseModule;
 
+fn hex_val() -> Format {
+    const HEX09: Range<u8> = b'0'..b'9';
+    const HEX_MAJ: Range<u8> = b'A'..b'F';
+    const HEX_MIN: Range<u8> = b'a'..b'f';
+
+    union([
+        map(byte_in(HEX09), lambda("b", sub(var("b"), Expr::U8(b'0')))),
+        map(
+            byte_in(HEX_MIN),
+            lambda("b", sub(var("b"), Expr::U8(b'a' - 10))),
+        ),
+        map(
+            byte_in(HEX_MAJ),
+            lambda("b", sub(var("b"), Expr::U8(b'A' - 10))),
+        ),
+    ])
+}
+
+fn record_daedalus<Name: IntoLabel + AsRef<str>>(
+    fields: impl IntoIterator<Item = (Name, Format), IntoIter: DoubleEndedIterator>,
+) -> Format {
+    let mut uniq_ix: Option<usize> = None;
+    let mut fields_ext = Vec::new();
+    for (_ix, (label, format)) in fields.into_iter().enumerate() {
+        let field = match label.as_ref() {
+            _nil if _nil.is_empty() || _nil.starts_with("__") => (None, format),
+            _tmp if _tmp.starts_with("_") || _tmp.starts_with("@") => {
+                (Some((Label::from(_tmp.to_owned()), true)), format)
+            }
+            uniq if uniq.starts_with("$$") => match uniq_ix.replace(_ix) {
+                None => {
+                    // patch all previous fields to be temporary
+                    for (fld_info, _) in fields_ext.iter_mut() {
+                        if let Some((_, is_persist)) = fld_info {
+                            *is_persist = false;
+                        }
+                    }
+                    (Some((uniq.replace("$", "x").into(), true)), format)
+                }
+                Some(old) => {
+                    unreachable!("cannot have more than one '$$' field: {} != {}", old, _ix)
+                }
+            },
+            other => (Some((other.to_owned().into(), uniq_ix.is_none())), format),
+        };
+        fields_ext.push(field)
+    }
+    record_ext(fields_ext, true)
+}
+
+fn hex_num_u32(len: usize) -> Format {
+    let raw = repeat_count(Expr::U32(len as u32), hex_val());
+    map(
+        raw,
+        lambda(
+            "raw",
+            left_fold(
+                lambda_tuple(["acc", "b"], add(var("b"), mul(var("acc"), Expr::U32(16)))),
+                Expr::U32(0),
+                ValueType::Base(BaseType::U32),
+                var("raw"),
+            ),
+        ),
+    )
+}
+
+fn interpret(assocs: impl IntoIterator<Item = (Format, Expr)>) -> Format {
+    union(assocs.into_iter().map(|(f, e)| monad_seq(f, compute(e))))
+}
+
 /// Greedily matches the given format, skipping any bytes that don't match.
-fn skip_to(f: Format) -> Format {
+fn skip_to(_f: Format) -> Format {
     // FIXME - we need a combinator for this to avoid infinite recursion while constructing the Format
-    Format::UnionNondet(vec![
-        f.clone(),
-        monad_seq(Format::ANY_BYTE, skip_to(f)),
-    ])
+    // Format::UnionNondet(vec![
+    //     f.clone(),
+    //     monad_seq(Format::ANY_BYTE, skip_to(f)),
+    // ])
+    todo!()
 }
 
+/// Parse `f` and ensure that there is no trailing content
 fn only(f: Format) -> Format {
     chain(f, "val", monad_seq(Format::EndOfInput, compute(var("val"))))
 }
@@ -21,79 +98,260 @@ fn void(f: Format) -> Format {
 
 /// Matches a string (as bytes) exactly, and returns it as a Seq(u8)
 fn match_str(bytes: &[u8]) -> Format {
-    todo!()
+    byte_seq(bytes)
 }
 
+const ASCII_LF: u8 = b'\n';
+const ASCII_CR: u8 = b'\r';
+
+const ASCII_NUL: u8 = b'\0';
+const ASCII_TAB: u8 = b'\t';
+const ASCII_FF: u8 = b'\x0c';
+const ASCII_SPACE: u8 = b' ';
+
+const __WS_MASK: u64 = 1u64 | 1 << ASCII_TAB | 1 << ASCII_FF | 1 << ASCII_SPACE;
+const SIMPLE_WS: ByteSet = ByteSet::from_bits([__WS_MASK, 0, 0, 0]);
+
+const DIGIT: ByteSet = ByteSet::from_bits([0b11_1111_1111 << b'0', 0, 0, 0]);
+
 pub fn main(module: &mut FormatModule, base: &BaseModule) -> FormatRef {
-    let simple_ws: ByteSet = ByteSet::from([0x00, 0x09, 0x0C, 0x20]);
-    let ascii_lf: u8 = 0x0A;
-    let ascii_cr: u8 = 0x0D;
+    {
+        let _simple_ws = ByteSet::from([b'\0', b'\t', 0x0C, b' ']);
+        debug_assert_eq!(_simple_ws, SIMPLE_WS);
 
-    let inline_char = Format::Byte(ByteSet::from([ascii_lf, ascii_cr]).complement());
+        let _digit = ByteSet::from(b'0'..=b'9');
+        debug_assert_eq!(_digit, DIGIT);
+    }
 
+    let inline_char = Format::Byte(ByteSet::from([ASCII_LF, ASCII_CR]).complement());
 
-    let simple_eol = module.define_format("pdf.util.simple_eol",
+    let simple_eol = module.define_format(
+        "pdf.util.simple_eol",
         Format::UnionNondet(vec![
-            void(is_bytes(&[ascii_cr, ascii_lf])),
-            void(is_byte(ascii_lf)),
-        ])
+            void(is_bytes(&[ASCII_CR, ASCII_LF])),
+            void(is_byte(ASCII_LF)),
+        ]),
     );
 
     let eol = module.define_format(
         "pdf.util.eol",
-        Format::UnionNondet(vec![
-            simple_eol.call(),
-            void(is_byte(ascii_cr)),
-        ])
+        Format::UnionNondet(vec![simple_eol.call(), void(is_byte(ASCII_CR))]),
     );
 
+    let then_eol =
+        |format: Format| chain(format, "ret", monad_seq(eol.call(), compute(var("ret"))));
+
     let comment = module.define_format(
         "pdf.util.comment",
-        monad_seq(
-            is_byte(b'%'),
-            monad_seq(
-                repeat(inline_char),
-                eol.call()
-            )
-        )
+        monad_seq(is_byte(b'%'), monad_seq(repeat(inline_char), eol.call())),
     );
 
-    let any_ws = module.define_format("pdf.util.any_ws",
+    let any_ws = module.define_format(
+        "pdf.util.any_ws",
         Format::UnionNondet(vec![
-            void(byte_in(simple_ws)), // $simpleWS
-            comment.call(), // Comment
-            eol.call(), // EOL
-        ])
+            void(byte_in(SIMPLE_WS)), // $simpleWS
+            comment.call(),           // Comment
+            eol.call(),               // EOL
+        ]),
     );
 
     let token = |f: Format| {
-        chain(f, "tok", monad_seq(repeat(any_ws.call()), compute(var("tok"))))
+        chain(
+            f,
+            "tok",
+            monad_seq(repeat(any_ws.call()), compute(var("tok"))),
+        )
     };
 
-    let unsigned_lead_digits = todo!();
+    let kw = |b: &[u8]| token(match_str(b));
+
+    let between = |open: &[u8], close: &[u8], f: Format| {
+        monad_seq(
+            kw(open),
+            chain(f, "val", monad_seq(kw(close), compute(var("val")))),
+        )
+    };
+
+    let natural = module.define_format("pdf.util.natural", repeat1(Format::Byte(DIGIT)));
+
+    let unsigned_lead_digits = chain(
+        natural.call(),
+        "n",
+        Format::UnionNondet(vec![
+            chain(
+                cons(is_byte(b'.'), repeat(Format::Byte(DIGIT))),
+                "frac",
+                compute(append(var("n"), var("frac"))),
+            ),
+            compute(var("n")),
+        ]),
+    );
 
     // TODO - add support to allow de-stringification of numbers
-    let unsigned_number = module.define_format("pdf.util.unsigned_number",
+    let unsigned_number = module.define_format(
+        "pdf.util.unsigned_number",
         Format::UnionNondet(vec![
-            unsigned_lead_digits.call(),
-            monad_seq(is_byte(b'.'), todo!()),
-        ])
+            unsigned_lead_digits,
+            cons(is_byte(b'.'), repeat1(Format::Byte(DIGIT))),
+        ]),
     );
+
     // TODO: add support to allow de-stringification of numbers
-    let number = module.define_format("pdf.util.number", union([
-        monad_seq(is_byte(b'-'), map(unsigned_number.call(), lambda("digits", concat(Expr::Seq(vec![Expr::Seq(vec![as_char(Expr::U8(b'-'))]), var("digits")]))))),
-        monad_seq(optional(is_byte(b'+')), unsigned_number.call()),
-    ]));
-
-    let pdf_chunk = todo!();
-
-    module.define_format("pdf.main",
-        only(
-            record_auto([
-                ("version", skip_to(monad_seq(is_bytes(b"%PDF-"), number.call()))),
-                ("chunks", repeat(pdf_chunk.call())),
-                ("__rem", repeat(any_ws.call())),
-            ])
-        )
+    let number = module.define_format(
+        "pdf.util.number",
+        union([
+            monad_seq(
+                is_byte(b'-'),
+                map(
+                    unsigned_number.call(),
+                    lambda(
+                        "digits",
+                        concat(Expr::Seq(vec![
+                            Expr::Seq(vec![as_char(Expr::U8(b'-'))]),
+                            var("digits"),
+                        ])),
+                    ),
+                ),
+            ),
+            monad_seq(optional(is_byte(b'+')), unsigned_number.call()),
+        ]),
+    );
+
+    let v_null = void(kw(b"null"));
+    let v_bool = interpret([
+        (kw(b"true"), Expr::Bool(true)),
+        (kw(b"false"), Expr::Bool(false)),
+    ]);
+    let v_ref = record_auto([
+        ("obj", token(natural.call())),
+        ("gen", token(natural.call())),
+        ("__kw", kw(b"R")),
+    ]);
+    let name_char = {
+        let ok_raw = ByteSet::from(*b"\0\t\n\x0C\r ()<>[]{}/%#").complement();
+        let name_esc = monad_seq(
+            is_byte(b'#'),
+            where_nonzero::<U8>(map(hex_num_u32(2), lambda("x32", as_u8(var("x32"))))),
+        );
+        union([Format::Byte(ok_raw), name_esc])
+    };
+    let v_name = module.define_format(
+        "pdf.value.name",
+        token(cons(is_byte(b'/'), repeat(name_char))),
+    );
+    let v_string = {
+        let string_in_parens = module.define_format_args(
+            "pdf.value.string_in_parens",
+            vec![(Label::Borrowed("lim"), ValueType::Base(BaseType::U64))],
+            if_then_else(
+                expr_eq(var("lim"), Expr::U64(0)),
+                Format::Fail, // "string nesting limit exceeded"
+                snoc(cons(match_str(b"("), todo!()), match_str(b")")), // TODO: support mutual recursion
+            ),
+        );
+
+        let string_esc = todo!();
+
+        let string_chunk = module.define_format_args(
+            "pdf.value.string_chunk",
+            vec![(Label::Borrowed("lim"), ValueType::Base(BaseType::U64))],
+            Format::UnionNondet(vec![
+                string_in_parens.call_args(vec![var("lim")]),
+                string_esc,
+                repeat1(byte_in(ByteSet::from(*b"\\()").complement())),
+            ]),
+        );
+
+        let string_chars = module.define_format_args(
+            "pdf.value.string_chars",
+            vec![(Label::Borrowed("lim"), ValueType::Base(BaseType::U64))],
+            map(
+                repeat(string_chunk.call_args(vec![var("lim")])),
+                lambda("xs", flat_map(lambda("x", var("x")), var("xs"))),
+            ),
+        );
+
+        record_daedalus([
+            ("__open", is_byte(b'(')),
+            ("$$", string_chars.call_args(vec![Expr::U64(16)])),
+            ("__close", is_byte(b')')),
+            ("__skipWS", repeat(any_ws.call())),
+        ])
+    };
+    let v_hex_string = { todo!() };
+    let pdf_value = module.define_format(
+        "pdf.value",
+        union_nondet([
+            ("null", v_null),
+            ("bool", v_bool),
+            ("ref", v_ref),
+            ("name", v_name.call()),
+            ("string", v_string),
+            ("string", v_hex_string),
+        ]),
+    );
+    let pdf_value_type = module.get_format_type(pdf_value.get_level()).clone();
+    let stream: FormatRef = todo!("implement Stream (val : Value)");
+    let top_decl_def = module.define_format_args(
+        "pdf.top_decl",
+        vec![(Label::Borrowed("val"), pdf_value_type)],
+        record([
+            ("stream", stream.call_args(vec![var("val")])),
+            ("value", compute(var("val"))),
+        ]),
+    );
+    let obj_decl = module.define_format(
+        "pdf.object",
+        record_auto([
+            ("id", token(natural.call())),
+            ("gen", token(natural.call())),
+            ("__kw_obj", kw(b"obj")),
+            ("_val", pdf_value.call()),
+            ("obj", top_decl_def.call_args(vec![var("_val")])),
+            ("__kw_end", kw(b"endobj")),
+        ]),
+    );
+    let cross_ref_section: FormatRef = todo!();
+    let pdf_dict = {
+        let dict = module.define_format_args(
+            "pdf.util.dict",
+            vec![(Label::Borrowed("lim"), ValueType::Base(BaseType::U64))],
+            between(
+                b"<<",
+                b">>",
+                repeat(record([
+                    ("key", v_name.call()),
+                    ("value", pdf_value.call_args(vec![var("lim")])),
+                ])),
+            ),
+        );
+
+        module.define_format("pdf.util.pdf-dict", dict.call_args(vec![Expr::U64(32)]))
+    };
+
+    let trailer = module.define_format("pdf.trailer", monad_seq(kw(b"trailer"), pdf_dict.call()));
+
+    let pdf_chunk = module.define_format(
+        "pdf.chunk",
+        record_auto([
+            ("objects", repeat(obj_decl.call())),
+            ("xref", cross_ref_section.call()),
+            ("trailer", trailer.call()),
+            ("__start_xref", then_eol(match_str(b"startxref"))),
+            ("declared_start_xref", then_eol(natural.call())),
+            ("__kw_eof", kw(b"%%EOF")),
+        ]),
+    );
+
+    module.define_format(
+        "pdf.main",
+        only(record_auto([
+            (
+                "version",
+                skip_to(monad_seq(is_bytes(b"%PDF-"), number.call())),
+            ),
+            ("chunks", repeat(pdf_chunk.call())),
+            ("__rem", repeat(any_ws.call())),
+        ])),
     )
 }
diff --git a/src/codegen/mod.rs b/src/codegen/mod.rs
index a81c0c17..96857b78 100644
--- a/src/codegen/mod.rs
+++ b/src/codegen/mod.rs
@@ -5114,7 +5114,10 @@ mod tests {
                 "{}",
                 lambda
                     .apply_pair(
-                        RustExpr::Owned(OwnedRustExpr { expr: Box::new(RustExpr::local("acc")), kind: OwnedKind::Cloned }),
+                        RustExpr::Owned(OwnedRustExpr {
+                            expr: Box::new(RustExpr::local("acc")),
+                            kind: OwnedKind::Cloned
+                        }),
                         RustExpr::local("seq"),
                         ExprInfo::default()
                     )
diff --git a/src/helper.rs b/src/helper.rs
index c1b21ed4..8476da7a 100644
--- a/src/helper.rs
+++ b/src/helper.rs
@@ -282,6 +282,35 @@ pub fn seq(formats: impl IntoIterator<Item = Format>) -> Format {
     Format::Sequence(formats.into_iter().collect())
 }
 
+/// Helper-function for [`Expr::Append`].
+pub fn append(expr0: Expr, expr1: Expr) -> Expr {
+    Expr::Append(Box::new(expr0), Box::new(expr1))
+}
+
+/// Balanced tree-merge using `Expr::Append` to concatenate N expressions.
+pub fn appends(exprs: impl IntoIterator<Item = Expr>) -> Expr {
+    let nodes = exprs.into_iter().collect();
+    balance_merge_dft((), move |_| nodes, append, || Expr::NIL)
+}
+
+/// Takes `Format(-> T), Format(-> [T])` and returns their mapped concatenation.
+pub fn cons(f_x: Format, f_xs: Format) -> Format {
+    chain(
+        f_x,
+        "x",
+        map(f_xs, lambda("xs", append(singleton(var("x")), var("xs")))),
+    )
+}
+
+/// Takes `Format(-> [T]), Format(-> T)` and returns their mapped concatenation.
+pub fn snoc(f_xs: Format, f_x: Format) -> Format {
+    chain(
+        f_xs,
+        "xs",
+        map(f_x, lambda("x", append(var("xs"), singleton(var("x"))))),
+    )
+}
+
 /// Helper-function for [`Format::Union`] over branches that are all [`Format::Variant`].
 ///
 /// Accepts any iterable container of tuples `(Name, Format)` for any `Name` that implements [`IntoLabel`].
@@ -401,7 +430,7 @@ pub fn record_auto<Name: IntoLabel + AsRef<str>>(
             (Some((label, !is_tmp)), format)
         }
     });
-    record_ext(fields_persist)
+    record_ext(fields_persist, false)
 }
 
 /// Bespoke record-constructor for new-style `Format`-level records.
@@ -417,16 +446,29 @@ pub fn record_ext<Name: IntoLabel>(
         Item = (Option<(Name, bool)>, Format),
         IntoIter: DoubleEndedIterator,
     >,
+    specialize_singletons: bool,
 ) -> Format {
-    let mut rev_fields = fields_persist
-        .into_iter()
-        .rev()
-        .collect::<Vec<(Option<(Name, bool)>, Format)>>();
-    let accum = Vec::with_capacity(rev_fields.len());
-    Format::Hint(
-        StyleHint::Record { old_style: false },
-        Box::new(Format::__chain_record(accum, &mut rev_fields)),
-    )
+    let (n_persist, mut rev_fields) = {
+        let mut tmp = fields_persist.into_iter();
+        let n_persist = tmp
+            .by_ref()
+            .filter(|(l, _)| l.as_ref().is_some_and(|(_, is_persist)| *is_persist))
+            .count();
+        (
+            n_persist,
+            tmp.rev().collect::<Vec<(Option<(Name, bool)>, Format)>>(),
+        )
+    };
+    if n_persist == 1 && specialize_singletons {
+        let accum = None;
+        Format::__chain_record_mono(accum, &mut rev_fields)
+    } else {
+        let accum = Vec::with_capacity(rev_fields.len());
+        Format::Hint(
+            StyleHint::Record { old_style: false },
+            Box::new(Format::__chain_record(accum, &mut rev_fields)),
+        )
+    }
 }
 
 /// Helper function that encloses a Format in an 'optional' context,
@@ -1137,8 +1179,9 @@ pub fn left_fold(f: Expr, init: Expr, init_vt: ValueType, seq: Expr) -> Expr {
 }
 
 /// Helper for constructing an `Expr::Seq` of length == 0
+#[inline]
 pub const fn seq_empty() -> Expr {
-    Expr::Seq(Vec::new())
+    Expr::NIL
 }
 
 /// Helper for constructing an `Expr::Seq` of length == 1
@@ -1152,6 +1195,8 @@ pub fn pair(x: Expr, y: Expr) -> Expr {
 }
 
 /// Computes the larger of two given `Expr`s, left-biased if equal
+///
+/// The expressions must be of the same, numeric ValueType.
 pub fn expr_max(a: Expr, b: Expr) -> Expr {
     expr_if_else(expr_gte(a.clone(), b.clone()), a, b)
 }
@@ -1283,19 +1328,15 @@ pub fn balanced_bitor(nodes: Vec<Expr>) -> Expr {
     balance_merge((), move |_| nodes, bit_or)
 }
 
-/// Generic function for computing an N-way binary operation using a generic seed-value
-/// and generation-function.
-///
-/// The `combine` operation should ideally be invariant under reordering and regrouping
-/// (i.e. commutative and associative) as the internal tree structure of the Expr is not
-/// specified.
+/// Balanced tree-fold, similar to [`balance_merge`], but with a default case
+/// for when the generator returns an empty vector.
 ///
-/// Relies on the guarantee that the given seed and initialization function will together
-/// produce a non-empty Vector, and will panic if the resulting vector is empty.
-pub fn balance_merge<Seed, MkNodes, Combine>(
+/// In order to allow panics in the default-case, the default case is passed as a closure.
+pub fn balance_merge_dft<Seed, MkNodes, Combine>(
     seed: Seed,
     mk_nodes: MkNodes,
     combine: Combine,
+    dft: impl FnOnce() -> Expr,
 ) -> Expr
 where
     MkNodes: FnOnce(Seed) -> Vec<Expr>,
@@ -1310,7 +1351,7 @@ where
     let mut stratum = nodes;
     loop {
         match stratum.len() {
-            0 => unreachable!("stratum cannot be empty"),
+            0 => return dft(),
             1 => return stratum.drain(..).next().unwrap(),
             _ => {
                 let mut tmp = Vec::with_capacity(stratum.len().div_ceil(2));
@@ -1331,6 +1372,29 @@ where
     }
 }
 
+/// Generic function for computing an N-way binary operation using a generic seed-value
+/// and generation-function.
+///
+/// The `combine` operation should ideally be invariant under reordering and regrouping
+/// (i.e. commutative and associative) as the internal tree structure of the Expr is not
+/// specified.
+///
+/// Relies on the guarantee that the given seed and initialization function will together
+/// produce a non-empty Vector, and will panic if the resulting vector is empty.
+pub fn balance_merge<Seed, MkNodes, Combine>(
+    seed: Seed,
+    mk_nodes: MkNodes,
+    combine: Combine,
+) -> Expr
+where
+    MkNodes: FnOnce(Seed) -> Vec<Expr>,
+    Combine: Fn(Expr, Expr) -> Expr,
+{
+    balance_merge_dft(seed, mk_nodes, combine, || {
+        panic!("stratum cannot be empty")
+    })
+}
+
 /// Helper function for `Format::AccumUntil`
 pub fn accum_until(
     f_done: Expr,
diff --git a/src/lib.rs b/src/lib.rs
index 653f998d..1b793be2 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -949,6 +949,43 @@ impl Format {
         )
     }
 
+    pub(crate) fn __chain_record_mono<Name: IntoLabel>(
+        mut capture: Option<(Label, Expr)>,
+        remaining: &mut Vec<(Option<(Name, bool)>, Format)>,
+    ) -> Format {
+        if remaining.is_empty() {
+            match capture {
+                None => unreachable!("promised single field-return, found nothing"),
+                Some((_, expr)) => Format::Compute(Box::new(expr)),
+            }
+        } else {
+            let this = remaining.pop().unwrap();
+            let (label, format) = this;
+            match label {
+                None => Format::MonadSeq(
+                    Box::new(format),
+                    Box::new(Format::__chain_record_mono(capture, remaining)),
+                ),
+                Some((name, is_persist)) => {
+                    let name: Label = name.into();
+                    if is_persist {
+                        match capture.replace((name.clone(), Expr::Var(name.clone()))) {
+                            None => (),
+                            Some(old) => {
+                                unreachable!("bad capture state: old: {:?}, new: {:?})", old, name)
+                            }
+                        }
+                    }
+                    Format::LetFormat(
+                        Box::new(format),
+                        name,
+                        Box::new(Format::__chain_record_mono(capture, remaining)),
+                    )
+                }
+            }
+        }
+    }
+
     pub(crate) fn __chain_record<Name: IntoLabel>(
         mut captured: Vec<(Label, Expr)>,
         remaining: &mut Vec<(Option<(Name, bool)>, Format)>,