libjay 0.3.0__tar.gz → 0.3.1__tar.gz

{libjay-0.3.0 → libjay-0.3.1}/Cargo.lock

@@ -494,7 +494,7 @@ checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2"
 
 [[package]]
 name = "libjay"
-version = "0.3.0"
+version = "0.3.1"
 dependencies = [
  "libjay-testkit",
  "multiversion",
@@ -510,14 +510,14 @@ dependencies = [
 
 [[package]]
 name = "libjay-capi"
-version = "0.3.0"
+version = "0.3.1"
 dependencies = [
  "libjay",
 ]
 
 [[package]]
 name = "libjay-devtools"
-version = "0.3.0"
+version = "0.3.1"
 dependencies = [
  "libjay",
  "libjay-testkit",
@@ -526,7 +526,7 @@ dependencies = [
 
 [[package]]
 name = "libjay-python"
-version = "0.3.0"
+version = "0.3.1"
 dependencies = [
  "arrow-array",
  "arrow-buffer",
@@ -538,7 +538,7 @@ dependencies = [
 
 [[package]]
 name = "libjay-testkit"
-version = "0.3.0"
+version = "0.3.1"
 dependencies = [
  "libjay",
 ]

{libjay-0.3.0 → libjay-0.3.1}/Cargo.toml

@@ -3,7 +3,7 @@ resolver = "2"
 members = ["crates/libjay", "crates/libjay-python", "crates/libjay-testkit"]
 
 [workspace.package]
-version = "0.3.0"
+version = "0.3.1"
 edition = "2024"
 rust-version = "1.89"
 license = "MIT"

{libjay-0.3.0 → libjay-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: libjay
-Version: 0.3.0
+Version: 0.3.1
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research

{libjay-0.3.0 → libjay-0.3.1}/crates/libjay/src/explain.rs

@@ -254,12 +254,13 @@ fn control_lines(c: &Control, depth: usize, p: &Program, tr: &Trace, out: &mut S
             block("test", test, out);
             block("body", body, out);
         }
-        Control::For { name, source, body } => {
-            let _ = writeln!(
-                out,
-                "{pad}for over items{}",
-                name.as_ref().map_or(String::new(), |n| format!(", item in {n}, index in {n}_index"))
-            );
+        Control::For { names, source, body } => {
+            let bound = match names.as_slice() {
+                [] => String::new(),
+                [n] => format!(", item in {n}, index in {n}_index"),
+                many => format!(", item taken apart into {}", many.join(" ")),
+            };
+            let _ = writeln!(out, "{pad}for over items{bound}");
             block("source", std::slice::from_ref(source), out);
             block("body", body, out);
         }

{libjay-0.3.0 → libjay-0.3.1}/crates/libjay/src/frontend/apl.rs

@@ -12,8 +12,8 @@ use std::sync::Arc;
 use crate::array::{Array, Data};
 use crate::error::{Error, Result, Span};
 use crate::frontend::{
-    DefaultArg, DepthSign, DfnResult, FirstDisclose, IndexForm, LookupLeft, NestedModel, Partition,
-    Rules, Segment, SourceParts,
+    ControlStrictness, DefaultArg, DepthSign, DfnResult, FirstDisclose, IndexForm, LookupLeft,
+    NestedModel, Partition, Rules, Segment, SourceParts,
 };
 use crate::ir::{Branch, Control, ExplicitDef, Expr, Scope};
 use crate::verb::{
@@ -28,6 +28,9 @@ use crate::verb::{
 pub fn parse(src: &SourceParts, d: Rules) -> Result<Vec<Expr>> {
     let sentences = lex(src, d)?;
     let mut verbs: HashMap<String, Verb> = HashMap::new();
+    for name in fixed_names(&sentences, d) {
+        verbs.entry(name.clone()).or_insert_with(|| Verb::Named(name.clone()));
+    }
     let mut stmts = Vec::with_capacity(sentences.len());
     let mut i = 0usize;
     while i < sentences.len() {
@@ -36,6 +39,22 @@ pub fn parse(src: &SourceParts, d: Rules) -> Result<Vec<Expr>> {
             stmts.push(stmt);
             continue;
         }
+        // A control structure standing on its own, outside any definition:
+        // its sentences are the lines of a body with nothing around them.
+        if let Some(Tok::Control(w)) = sentences[i].first().map(|t| &t.kind)
+            && matches!(*w, "If" | "While" | "Repeat" | "For" | "Select")
+        {
+            let end = control_block_end(&sentences, i).unwrap_or(sentences.len());
+            let mut items = Vec::with_capacity(end - i);
+            for line in &sentences[i..end] {
+                let mut label = None;
+                items.push(to_item(line.clone(), d, &mut verbs, &mut label)?);
+            }
+            let mut cursor = AplCursor { items: &items, at: 0, d, loops: 0 };
+            stmts.push(parse_apl_control(&mut cursor)?);
+            i = end;
+            continue;
+        }
         let mut sentence = sentences[i].clone();
         i += 1;
         // `⎕FX` defines a function where it stands; the sentence keeps only
@@ -57,6 +76,67 @@ pub fn parse(src: &SourceParts, d: Rules) -> Result<Vec<Expr>> {
     Ok(stmts)
 }
 
+/// The functions the program fixes anywhere in it, by name.
+///
+/// APL settles a name's class when the line runs; libjay compiles first, so
+/// a definition whose body calls a function fixed AFTER it would have
+/// nothing to call. The names every `∇` and `⎕FX` in the program gives a
+/// function are therefore collected before anything is parsed, and each
+/// stands as a verb resolved when it is applied — the definition it names
+/// has been fixed by then. A header this cannot read is skipped: parsing
+/// the definition itself reports the fault.
+fn fixed_names(sentences: &[Vec<Token>], d: Rules) -> Vec<String> {
+    let mut out = Vec::new();
+    for line in sentences {
+        let head = match line.first().map(|t| &t.kind) {
+            Some(Tok::Del) => line[1..].to_vec(),
+            _ => {
+                let Some(at) = line.iter().position(|t| matches!(t.kind, Tok::QuadFx)) else {
+                    continue;
+                };
+                let Some(Tok::Value(a)) = line.get(at + 1).map(|t| &t.kind) else {
+                    continue;
+                };
+                let Data::Char(cs) = &a.data else { continue };
+                if a.rank() > 1 {
+                    continue;
+                }
+                let text: String = cs.iter().collect();
+                let src = SourceParts::from_parts(&[&text], &[]);
+                match lex(&src, d) {
+                    Ok(mut lexed) if lexed.len() == 1 => lexed.pop().unwrap_or_default(),
+                    _ => continue,
+                }
+            }
+        };
+        let Some(first) = head.first() else { continue };
+        if let Ok((name, ..)) = parse_header(&head, first.span) {
+            out.push(name);
+        }
+    }
+    out
+}
+
+/// The sentence after the one that closes the control structure opening at
+/// `at`. None where nothing closes it, which the block parser reports.
+fn control_block_end(sentences: &[Vec<Token>], at: usize) -> Option<usize> {
+    let mut depth = 0usize;
+    for (k, line) in sentences.iter().enumerate().skip(at) {
+        let Some(Tok::Control(w)) = line.first().map(|t| &t.kind) else { continue };
+        match *w {
+            "If" | "While" | "Repeat" | "For" | "Select" => depth += 1,
+            "EndIf" | "EndWhile" | "EndFor" | "EndSelect" | "Until" | "End" => {
+                depth -= 1;
+                if depth == 0 {
+                    return Some(k + 1);
+                }
+            }
+            _ => {}
+        }
+    }
+    None
+}
+
 /// Where a `⎕FX` stands in a sentence of its own rather than inside a dfn's
 /// braces. One inside a body belongs to that body, which is compiled when
 /// the definition is, so it is left where it is and named there as a gap.
@@ -195,11 +275,11 @@ fn parse_statement(
         }
         return Ok(Some(Expr::VerbDef { name: n.clone(), verb: v, span }));
     }
+    // A control word that opens a structure is taken before the sentence
+    // is; anything left here continues or closes one that never opened.
     if let Some(t) = toks.iter().find(|t| matches!(t.kind, Tok::Control(_))) {
-        return Err(Error::parse(
-            "control structures are only meaningful inside a ∇ definition",
-            t.span,
-        ));
+        let Tok::Control(w) = t.kind else { unreachable!() };
+        return Err(Error::parse(format!(":{w} has no matching opening word"), t.span));
     }
     if let Some(t) = toks.iter().find(|t| matches!(t.kind, Tok::Arrow)) {
         return Err(Error::parse(
@@ -2434,9 +2514,10 @@ fn match_lparen(toks: &[Token], lo: usize, rparen: usize) -> Result<usize> {
 /// APL's control words, without their colon. `:End` closes any of the
 /// structures, which is the spelling GNU APL's manual gives as an
 /// alternative to the named closers.
-const CONTROL_WORDS: [&str; 18] = [
-    "If", "ElseIf", "Else", "EndIf", "While", "EndWhile", "Repeat", "Until", "For", "In",
-    "EndFor", "Select", "Case", "EndSelect", "Return", "Leave", "Continue", "End",
+const CONTROL_WORDS: [&str; 21] = [
+    "If", "ElseIf", "Else", "EndIf", "AndIf", "OrIf", "While", "EndWhile", "Repeat", "Until",
+    "For", "In", "EndFor", "Select", "Case", "CaseList", "EndSelect", "Return", "Leave",
+    "Continue", "End",
 ];
 
 /// The control word a `:name` spells, case-insensitively as the references
@@ -2812,7 +2893,7 @@ fn build_tradfn(
         items.push(item);
     }
     let item_count = items.len();
-    let mut cursor = AplCursor { items: &items, at: 0, d };
+    let mut cursor = AplCursor { items: &items, at: 0, d, loops: 0 };
     let mut body = parse_apl_block(&mut cursor, &[])?;
     // A label is the number of a LINE, so the statements have to be the
     // lines: a control structure folds several of them into one and the
@@ -2968,6 +3049,9 @@ struct AplCursor<'a> {
     at: usize,
     /// The dialect, for the sentences a control word carries.
     d: Rules,
+    /// How many loops enclose the position being parsed, which is what
+    /// decides whether a `:Leave` has one to leave.
+    loops: usize,
 }
 
 impl<'a> AplCursor<'a> {
@@ -2985,6 +3069,14 @@ impl<'a> AplCursor<'a> {
             .map_or_else(|| Span::new(0, 0), AplItem::span)
     }
 
+    /// Parse a loop's body, with the loop counted around it.
+    fn in_loop<T>(&mut self, f: impl FnOnce(&mut Self) -> Result<T>) -> Result<T> {
+        self.loops += 1;
+        let out = f(self);
+        self.loops -= 1;
+        out
+    }
+
     /// Consume the closing word, which may also be spelled `:End`.
     fn close(&mut self, want: &str) -> Result<()> {
         match self.peek_word() {
@@ -3031,8 +3123,14 @@ fn parse_apl_control(cur: &mut AplCursor<'_>) -> Result<Expr> {
             let mut test = rest;
             loop {
                 let test_expr = condition(test, start, cur.d)?;
+                let test_expr = continued_condition(cur, test_expr)?;
                 let body = parse_apl_block(cur, &["ElseIf", "Else", "EndIf"])?;
-                arms.push(Branch { test: Some(vec![test_expr]), body, fall_through: false });
+                arms.push(Branch {
+                    test: Some(vec![test_expr]),
+                    body,
+                    fall_through: false,
+                    list: false,
+                });
                 match cur.peek_word() {
                     Some("ElseIf") => {
                         let Some(AplItem::Word { rest, .. }) = cur.peek() else { unreachable!() };
@@ -3055,7 +3153,8 @@ fn parse_apl_control(cur: &mut AplCursor<'_>) -> Result<Expr> {
         }
         "While" => {
             let test = condition(rest, start, cur.d)?;
-            let body = parse_apl_block(cur, &["EndWhile"])?;
+            let test = continued_condition(cur, test)?;
+            let body = cur.in_loop(|cur| parse_apl_block(cur, &["EndWhile"]))?;
             cur.close("EndWhile")?;
             Control::While { test: vec![test], body, body_first: false, until: false }
         }
@@ -3063,40 +3162,50 @@ fn parse_apl_control(cur: &mut AplCursor<'_>) -> Result<Expr> {
             if !rest.is_empty() {
                 return Err(Error::parse(":Repeat takes no condition", start));
             }
-            let body = parse_apl_block(cur, &["Until"])?;
+            let body = cur.in_loop(|cur| parse_apl_block(cur, &["Until"]))?;
             let Some(AplItem::Word { rest, span, .. }) = cur.peek() else {
                 return Err(Error::parse("this :Repeat needs an :Until", cur.last_span()));
             };
-            let test = condition(rest.clone(), *span, cur.d)?;
+            let (rest, span) = (rest.clone(), *span);
+            let test = condition(rest, span, cur.d)?;
             cur.at += 1;
+            let test = continued_condition(cur, test)?;
             Control::While { test: vec![test], body, body_first: true, until: true }
         }
         "For" => {
-            // `:For name :In source`.
-            let (name, source) = for_header(&rest, start, cur.d)?;
-            let body = parse_apl_block(cur, &["EndFor"])?;
+            // `:For name… :In source`.
+            let (names, source) = for_header(&rest, start, cur.d)?;
+            let body = cur.in_loop(|cur| parse_apl_block(cur, &["EndFor"]))?;
             cur.close("EndFor")?;
-            Control::For { name: Some(name), source: Box::new(source), body }
+            Control::For { names, source: Box::new(source), body }
         }
         "Select" => {
             let subject = condition(rest, start, cur.d)?;
             let mut cases = Vec::new();
             loop {
                 match cur.peek() {
-                    Some(AplItem::Word { word: "Case", rest, span }) => {
+                    Some(AplItem::Word { word: w @ ("Case" | "CaseList"), rest, span }) => {
+                        let list = *w == "CaseList";
                         let test = condition(rest.clone(), *span, cur.d)?;
                         cur.at += 1;
-                        let body = parse_apl_block(cur, &["Case", "Else", "EndSelect"])?;
+                        let body =
+                            parse_apl_block(cur, &["Case", "CaseList", "Else", "EndSelect"])?;
                         cases.push(Branch {
                             test: Some(vec![test]),
                             body,
                             fall_through: false,
+                            list,
                         });
                     }
                     Some(AplItem::Word { word: "Else", .. }) => {
                         cur.at += 1;
                         let body = parse_apl_block(cur, &["EndSelect"])?;
-                        cases.push(Branch { test: None, body, fall_through: false });
+                        cases.push(Branch {
+                            test: None,
+                            body,
+                            fall_through: false,
+                            list: false,
+                        });
                         cur.close("EndSelect")?;
                         break;
                     }
@@ -3109,8 +3218,14 @@ fn parse_apl_control(cur: &mut AplCursor<'_>) -> Result<Expr> {
             Control::Select { subject: Box::new(subject), cases }
         }
         "Return" => Control::Return,
-        "Leave" => Control::Break,
-        "Continue" => Control::Continue,
+        // Dyalog wants a loop around `:Leave` and `:Continue`; the lenient
+        // reading lets a stray one leave the definition instead.
+        "Leave" | "Continue" => {
+            if cur.loops == 0 && cur.d.control_strictness == ControlStrictness::Strict {
+                return Err(Error::parse(format!(":{word} belongs inside a loop"), start));
+            }
+            if word == "Leave" { Control::Break } else { Control::Continue }
+        }
         other => {
             return Err(Error::parse(format!(":{other} has no matching opening word"), start));
         }
@@ -3118,6 +3233,46 @@ fn parse_apl_control(cur: &mut AplCursor<'_>) -> Result<Expr> {
     Ok(Expr::Control(Box::new(control), Span::merge(start, cur.last_span())))
 }
 
+/// The `:AndIf` and `:OrIf` lines that continue the condition above them.
+///
+/// Both SHORT-CIRCUIT: the second test does not run where the first has
+/// settled the answer. A test is a block, whose value is its last
+/// sentence's, so the two cannot simply be listed; the continuation is an
+/// `:If` of its own instead, answering with the next test where the first
+/// leaves the question open and with the settled truth value where it does
+/// not. They chain left to right, `:AndIf` and `:OrIf` alike.
+fn continued_condition(cur: &mut AplCursor<'_>, mut test: Expr) -> Result<Expr> {
+    loop {
+        let (word, rest, span) = match cur.peek() {
+            Some(AplItem::Word { word: w @ ("AndIf" | "OrIf"), rest, span }) => {
+                (*w, rest.clone(), *span)
+            }
+            _ => return Ok(test),
+        };
+        cur.at += 1;
+        let next = condition(rest, span, cur.d)?;
+        let settled = Expr::Const(Array::scalar_bool(word == "OrIf"), span);
+        let (body, otherwise) = if word == "AndIf" {
+            (vec![next], vec![settled])
+        } else {
+            (vec![settled], vec![next])
+        };
+        let whole = Span::merge(test.span(), span);
+        test = Expr::Control(
+            Box::new(Control::If {
+                arms: vec![Branch {
+                    test: Some(vec![test]),
+                    body,
+                    fall_through: false,
+                    list: false,
+                }],
+                otherwise: Some(otherwise),
+            }),
+            whole,
+        );
+    }
+}
+
 /// The tokens after a control word, as one expression.
 fn condition(rest: Vec<Token>, span: Span, d: Rules) -> Result<Expr> {
     match rest.first() {
@@ -3135,23 +3290,28 @@ fn condition(rest: Vec<Token>, span: Span, d: Rules) -> Result<Expr> {
     }
 }
 
-/// `:For name :In source`.
-fn for_header(rest: &[Token], span: Span, d: Rules) -> Result<(String, Expr)> {
-    let Some(Tok::Name(name)) = rest.first().map(|t| &t.kind) else {
-        return Err(Error::parse(":For needs a name to bind", span));
-    };
+/// `:For name… :In source`. Several names take each item apart between
+/// them, one of its own items each.
+fn for_header(rest: &[Token], span: Span, d: Rules) -> Result<(Vec<String>, Expr)> {
     let Some(k) = rest.iter().position(|t| matches!(t.kind, Tok::Control("In"))) else {
         return Err(Error::parse(":For needs an :In", span));
     };
-    if k != 1 {
-        return Err(Error::not_yet("several :For names", span));
+    let mut names = Vec::with_capacity(k);
+    for t in &rest[..k] {
+        match &t.kind {
+            Tok::Name(n) => names.push(n.clone()),
+            _ => return Err(Error::parse(":For binds names, one per item", t.span)),
+        }
+    }
+    if names.is_empty() {
+        return Err(Error::parse(":For needs a name to bind", span));
     }
     let source = &rest[k + 1..];
     let Some(first) = source.first() else {
         return Err(Error::parse(":In needs a value", span));
     };
     let hint = Span::merge(first.span, source[source.len() - 1].span);
-    Ok((name.clone(), parse_prepared(source, hint, d)?))
+    Ok((names, parse_prepared(source, hint, d)?))
 }
 
 /// Parse a token run that has already had its names and dfns folded.

{libjay-0.3.0 → libjay-0.3.1}/crates/libjay/src/frontend/j.rs

@@ -841,7 +841,7 @@ fn parse_control(cur: &mut Cursor<'_>, scope: &mut Names) -> Result<Expr> {
             let body = parse_block(cur, scope, &["end."])?;
             let end = cur.expect("end.")?;
             let source = one_expr(source, Span::merge(start, end))?;
-            Control::For { name: suffix.clone(), source: Box::new(source), body }
+            Control::For { names: suffix.iter().cloned().collect(), source: Box::new(source), body }
         }
         "select." => parse_select(cur, scope, start)?,
         "try." => {
@@ -883,7 +883,7 @@ fn parse_if(cur: &mut Cursor<'_>, scope: &mut Names) -> Result<Control> {
         let test = parse_block(cur, scope, &["do."])?;
         cur.expect("do.")?;
         let body = parse_block(cur, scope, &["elseif.", "else.", "end."])?;
-        arms.push(Branch { test: Some(test), body, fall_through: false });
+        arms.push(Branch { test: Some(test), body, fall_through: false, list: false });
         match cur.peek_word() {
             Some("elseif.") => {
                 cur.at += 1;
@@ -927,7 +927,7 @@ fn parse_select(cur: &mut Cursor<'_>, scope: &mut Names, start: Span) -> Result<
         let body = parse_block(cur, scope, &["case.", "fcase.", "end."])?;
         // `case. do.` with no test is the default arm.
         let test = (!test.is_empty()).then_some(test);
-        cases.push(Branch { test, body, fall_through });
+        cases.push(Branch { test, body, fall_through, list: false });
     }
     Ok(Control::Select { subject: Box::new(subject), cases })
 }

{libjay-0.3.0 → libjay-0.3.1}/crates/libjay/src/frontend/mod.rs

@@ -219,6 +219,43 @@ pub enum EncodeDigits {
     Exact,
 }
 
+/// How strictly a control structure reads what it is given.
+///
+/// The lenient reading is the one both languages ship: a condition is true
+/// where its first atom is, whatever else it holds, and a `:Leave` outside
+/// a loop leaves the definition. Dyalog reads both strictly — a condition
+/// is one element and no more, and `:Leave` belongs to a loop — and says so
+/// rather than answering. GNU APL has no control structures at all, so
+/// nothing it records turns on this.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub enum ControlStrictness {
+    /// The first atom decides, and a stray `:Leave` is a return.
+    #[default]
+    Lenient,
+    /// Dyalog: a condition is a single value, and `:Leave` needs its loop.
+    Strict,
+}
+
+/// Where the each in the inner product's definition sits.
+///
+/// `f.g` is a fold over a pairing, and the two lines put the each on
+/// different halves of it. GNU APL puts it on the FOLD — `f/¨ (⊂[last]x)
+/// ∘.g (⊂[first]y)` — so `g` meets one whole vector from each side and what
+/// the fold makes of a pair is enclosed once more. Dyalog puts it on the
+/// PAIRING — `f/ row g¨ column` — so `g` meets one element from each side
+/// and the fold's own value stands as the cell. `1 2+.,3 4` is `10` under
+/// the first and an enclosed `3 7` under the second. The two agree wherever
+/// `g` is a scalar function and the fold ends in a number, which is every
+/// published use, so `+.×` and the Life idiom's `∨.∧` differ only in depth.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub enum InnerEach {
+    /// GNU APL: `f/¨` over the outer product.
+    #[default]
+    OnFold,
+    /// Dyalog: `f/` over `g¨`.
+    OnPair,
+}
+
 /// Dialect settings supplied by the host.
 ///
 /// This is what a host asks for; [`Rules`] is what the compiler and the
@@ -252,6 +289,8 @@ pub struct Dialect {
     pub near_count: NearCount,
     pub floor_rule: FloorRule,
     pub encode_digits: EncodeDigits,
+    pub inner_each: InnerEach,
+    pub control_strictness: ControlStrictness,
     /// Whether a function may stand where a value belongs: a run of
     /// functions is then a train, and `F←+/` names one. Both readings are
     /// implemented, so this is a choice and not a gap. It ships on, as an
@@ -290,6 +329,8 @@ impl Dialect {
             near_count: NearCount::Absolute,
             floor_rule: FloorRule::Shift,
             encode_digits: EncodeDigits::Tolerant,
+            inner_each: InnerEach::OnFold,
+            control_strictness: ControlStrictness::Lenient,
             trains: true,
         }
     }
@@ -320,6 +361,8 @@ impl Dialect {
             near_count: NearCount::Tolerant,
             floor_rule: FloorRule::Scaled,
             encode_digits: EncodeDigits::Exact,
+            inner_each: InnerEach::OnPair,
+            control_strictness: ControlStrictness::Strict,
             trains: true,
         }
     }
@@ -395,6 +438,8 @@ impl Dialect {
             near_count: self.near_count,
             floor_rule: self.floor_rule,
             encode_digits: self.encode_digits,
+            inner_each: self.inner_each,
+            control_strictness: self.control_strictness,
             trains: self.trains,
         })
     }
@@ -427,6 +472,8 @@ pub struct Rules {
     pub near_count: NearCount,
     pub floor_rule: FloorRule,
     pub encode_digits: EncodeDigits,
+    pub inner_each: InnerEach,
+    pub control_strictness: ControlStrictness,
     pub trains: bool,
 }
 
@@ -456,6 +503,8 @@ impl Rules {
             near_count: self.near_count,
             floor_rule: self.floor_rule,
             encode_digits: self.encode_digits,
+            inner_each: self.inner_each,
+            control_strictness: self.control_strictness,
             trains: self.trains,
         }
     }