libjay 0.2.0__tar.gz → 0.2.1__tar.gz

{libjay-0.2.0 → libjay-0.2.1}/Cargo.lock

@@ -494,7 +494,7 @@ checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2"
 
 [[package]]
 name = "libjay"
-version = "0.2.0"
+version = "0.2.1"
 dependencies = [
  "libjay-testkit",
  "multiversion",
@@ -510,14 +510,14 @@ dependencies = [
 
 [[package]]
 name = "libjay-capi"
-version = "0.2.0"
+version = "0.2.1"
 dependencies = [
  "libjay",
 ]
 
 [[package]]
 name = "libjay-devtools"
-version = "0.2.0"
+version = "0.2.1"
 dependencies = [
  "libjay-testkit",
  "rayon",
@@ -525,7 +525,7 @@ dependencies = [
 
 [[package]]
 name = "libjay-python"
-version = "0.2.0"
+version = "0.2.1"
 dependencies = [
  "arrow-array",
  "arrow-buffer",
@@ -537,7 +537,7 @@ dependencies = [
 
 [[package]]
 name = "libjay-testkit"
-version = "0.2.0"
+version = "0.2.1"
 dependencies = [
  "libjay",
 ]

{libjay-0.2.0 → libjay-0.2.1}/Cargo.toml

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

{libjay-0.2.0 → libjay-0.2.1}/PKG-INFO

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

{libjay-0.2.0 → libjay-0.2.1}/crates/libjay/src/array.rs

@@ -436,6 +436,10 @@ pub enum Data {
     /// pair of Arrow float columns all share.
     Complex(Buf<Cx>),
     Char(Buf<char>),
+    /// Symbols: every element is an index into the process-wide symbol
+    /// table (see [`crate::symbol`]), so the buffer is as flat and as
+    /// cheap to copy as one of integers and the names live once each.
+    Symbol(Buf<crate::symbol::Id>),
     /// Boxes: every element is a whole array. Foreign memory never holds
     /// these, so a boxed buffer is always owned and cloning it is a
     /// refcount bump like any other.
@@ -452,6 +456,7 @@ impl Data {
             Data::F64(_) => DType::F64,
             Data::Complex(_) => DType::Complex,
             Data::Char(_) => DType::Char,
+            Data::Symbol(_) => DType::Symbol,
             Data::Box(_) => DType::Box,
         }
     }
@@ -465,6 +470,7 @@ impl Data {
             Data::F64(v) => v.len(),
             Data::Complex(v) => v.len(),
             Data::Char(v) => v.len(),
+            Data::Symbol(v) => v.len(),
             Data::Box(v) => v.len(),
         }
     }
@@ -483,6 +489,7 @@ impl Data {
             Data::F64(v) => v.is_foreign(),
             Data::Complex(v) => v.is_foreign(),
             Data::Char(v) => v.is_foreign(),
+            Data::Symbol(v) => v.is_foreign(),
             Data::Box(v) => v.is_foreign(),
         }
     }
@@ -498,6 +505,7 @@ impl Data {
             Data::F64(v) => v.owner(),
             Data::Complex(v) => v.owner(),
             Data::Char(v) => v.owner(),
+            Data::Symbol(v) => v.owner(),
             Data::Box(v) => v.owner(),
         }
     }
@@ -511,6 +519,7 @@ impl Data {
             Data::F64(v) => Data::F64(v.slice(start, end)),
             Data::Complex(v) => Data::Complex(v.slice(start, end)),
             Data::Char(v) => Data::Char(v.slice(start, end)),
+            Data::Symbol(v) => Data::Symbol(v.slice(start, end)),
             Data::Box(v) => Data::Box(v.slice(start, end)),
         }
     }
@@ -524,6 +533,7 @@ impl Data {
             DType::F64 => Data::F64(Buf::new()),
             DType::Complex => Data::Complex(Buf::new()),
             DType::Char => Data::Char(Buf::new()),
+            DType::Symbol => Data::Symbol(Buf::new()),
             DType::Box => Data::Box(Buf::new()),
         }
     }
@@ -539,6 +549,7 @@ impl Data {
             Data::F64(v) => v.push(0.0),
             Data::Complex(v) => v.push(crate::complex::ZERO),
             Data::Char(v) => v.push(' '),
+            Data::Symbol(v) => v.push(crate::symbol::EMPTY),
             Data::Box(v) => v.push(Array::box_fill()),
         }
     }
@@ -554,6 +565,7 @@ impl Data {
             (Data::F64(a), Data::F64(b)) => a.push(b[i]),
             (Data::Complex(a), Data::Complex(b)) => a.push(b[i]),
             (Data::Char(a), Data::Char(b)) => a.push(b[i]),
+            (Data::Symbol(a), Data::Symbol(b)) => a.push(b[i]),
             (Data::Box(a), Data::Box(b)) => a.push(b[i].clone()),
             _ => {}
         }
@@ -568,6 +580,7 @@ impl Data {
             (Data::F64(a), Data::F64(b)) => a.extend_from_slice(b),
             (Data::Complex(a), Data::Complex(b)) => a.extend_from_slice(b),
             (Data::Char(a), Data::Char(b)) => a.extend_from_slice(b),
+            (Data::Symbol(a), Data::Symbol(b)) => a.extend_from_slice(b),
             (Data::Box(a), Data::Box(b)) => a.extend_from_slice(b),
             _ => return false,
         }
@@ -605,6 +618,7 @@ impl Data {
             DType::F64 => by!(F64, Buf::join_fast),
             DType::Complex => by!(Complex, Buf::join_fast),
             DType::Char => by!(Char, Buf::join),
+            DType::Symbol => by!(Symbol, Buf::join_fast),
             DType::Ext => by!(Ext, Buf::join),
             DType::Rat => by!(Rat, Buf::join),
             DType::Box => by!(Box, Buf::join),
@@ -703,6 +717,7 @@ impl Data {
             DType::F64 => by!(F64, weave),
             DType::Complex => by!(Complex, weave),
             DType::Char => by!(Char, weave),
+            DType::Symbol => by!(Symbol, weave),
             DType::Ext => by!(Ext, weave_cloned),
             DType::Rat => by!(Rat, weave_cloned),
             DType::Box => by!(Box, weave_cloned),
@@ -1035,7 +1050,7 @@ impl Array {
             Data::Rat(v) => Some(v.iter().map(|x| [x.to_f64(), 0.0]).collect()),
             Data::F64(v) => Some(v.iter().map(|&x| [x, 0.0]).collect()),
             Data::Complex(v) => Some(v.to_vec()),
-            Data::Char(_) | Data::Box(_) => None,
+            Data::Char(_) | Data::Symbol(_) | Data::Box(_) => None,
         }
     }
 
@@ -1049,7 +1064,7 @@ impl Array {
             Data::F64(v) => Some(v.to_vec()),
             // A complex value is not a real one, even when its imaginary
             // part is zero: the caller wants a real and must ask for it.
-            Data::Complex(_) | Data::Char(_) | Data::Box(_) => None,
+            Data::Complex(_) | Data::Char(_) | Data::Symbol(_) | Data::Box(_) => None,
         }
     }
 
@@ -1074,7 +1089,7 @@ impl Array {
                 }
                 Some(out)
             }
-            Data::Complex(_) | Data::Char(_) | Data::Box(_) => None,
+            Data::Complex(_) | Data::Char(_) | Data::Symbol(_) | Data::Box(_) => None,
         }
     }
 }

{libjay-0.2.0 → libjay-0.2.1}/crates/libjay/src/dtype.rs

@@ -13,6 +13,9 @@ pub enum DType {
     /// A complex number, held as an interleaved `[re, im]` pair.
     Complex,
     Char,
+    /// An interned name (J `s:`). The element is an index into the
+    /// process-wide symbol table, not the text itself.
+    Symbol,
     /// A box: every element is itself an array (J `<`, APL `⊂`).
     Box,
 }
@@ -27,6 +30,7 @@ impl DType {
             DType::F64 => "float",
             DType::Complex => "complex",
             DType::Char => "character",
+            DType::Symbol => "symbol",
             DType::Box => "boxed",
         }
     }
@@ -55,6 +59,8 @@ impl DType {
             (Box, _) | (_, Box) => None,
             (Char, Char) => Some(Char),
             (Char, _) | (_, Char) => None,
+            (Symbol, Symbol) => Some(Symbol),
+            (Symbol, _) | (_, Symbol) => None,
             (Complex, _) | (_, Complex) => Some(Complex),
             (F64, _) | (_, F64) => Some(F64),
             (Rat, _) | (_, Rat) => Some(Rat),
@@ -85,5 +91,8 @@ mod tests {
     fn characters_and_boxes_mix_with_nothing() {
         assert_eq!(super::DType::promote(Char, Ext), None);
         assert_eq!(super::DType::promote(Box, Rat), None);
+        assert_eq!(super::DType::promote(Symbol, Char), None);
+        assert_eq!(super::DType::promote(Symbol, I64), None);
+        assert_eq!(super::DType::promote(Symbol, Symbol), Some(Symbol));
     }
 }

{libjay-0.2.0 → libjay-0.2.1}/crates/libjay/src/explain.rs

@@ -426,6 +426,11 @@ fn verb_lines(v: &Verb, depth: usize, p: &Program, tr: &Trace, out: &mut String)
             verb_lines(f, depth + 1, p, tr, out);
             verb_lines(g, depth + 1, p, tr, out);
         }
+        Verb::InnerProduct { u, v, .. } => {
+            head(out, "inner product (u . v; the matrix product for +/ . *)");
+            verb_lines(u, depth + 1, p, tr, out);
+            verb_lines(v, depth + 1, p, tr, out);
+        }
         Verb::UserDerived { def, alpha, omega } => {
             head(out, "a user-written operator with its operands");
             verb_lines(def, depth + 1, p, tr, out);

{libjay-0.2.0 → libjay-0.2.1}/crates/libjay/src/fmt.rs

@@ -52,14 +52,35 @@ pub fn format_array(a: &Array, opts: &FmtOpts) -> String {
         // rather than with a nested display's extra spacing.
         match mixed_simple_texts(a, opts) {
             Some(texts) if opts.boxes == BoxStyle::Spaced => {
-                return laid_out(&a.shape, texts, false)
+                return laid_out(&a.shape, texts, Cells::Right)
             }
             _ => return format_boxed(a, opts),
         }
     }
     let texts: Vec<String> = (0..a.count()).map(|i| format_atom(&a.data, i, opts)).collect();
-    // Characters are laid out as text lines; everything else as columns.
-    laid_out(&a.shape, texts, a.dtype() == DType::Char)
+    laid_out(&a.shape, texts, Cells::of(a.dtype()))
+}
+
+/// How the formatted elements of one row sit next to each other.
+#[derive(Clone, Copy, PartialEq)]
+enum Cells {
+    /// Numbers: one space between columns, each column right-aligned.
+    Right,
+    /// Characters: no separator at all, because the row IS the text.
+    Text,
+    /// Symbols: one space between columns, each column left-aligned and
+    /// padded on the right, which is how J prints a table of names.
+    Left,
+}
+
+impl Cells {
+    fn of(dtype: DType) -> Cells {
+        match dtype {
+            DType::Char => Cells::Text,
+            DType::Symbol => Cells::Left,
+            _ => Cells::Right,
+        }
+    }
 }
 
 /// The scalar each element of a boxed array holds, where every one of them
@@ -78,19 +99,23 @@ fn mixed_simple_texts(a: &Array, opts: &FmtOpts) -> Option<Vec<String>> {
 
 /// One formatted element per position, laid out for the shape: a vector on
 /// one line, higher ranks as aligned columns and planes.
-fn laid_out(shape: &[usize], texts: Vec<String>, text_layout: bool) -> String {
+fn laid_out(shape: &[usize], texts: Vec<String>, cells: Cells) -> String {
     let rank = shape.len();
     let a_shape = shape;
     match rank {
         0 => texts.into_iter().next().unwrap_or_default(),
-        1 if text_layout => texts.concat(),
+        1 if cells == Cells::Text => texts.concat(),
         1 => texts.join(" "),
         _ => {
             let ncols = a_shape[rank - 1];
             let nrows = a_shape[rank - 2];
             // Column widths span every plane, so planes stay aligned with
             // each other and not just internally.
-            let widths = if text_layout { vec![0; ncols] } else { column_widths(&texts, ncols) };
+            let widths = if cells == Cells::Text {
+                vec![0; ncols]
+            } else {
+                column_widths(&texts, ncols)
+            };
             let frame = &a_shape[..rank - 2];
             let plane_size = nrows * ncols;
             let planes: usize = frame.iter().product();
@@ -105,7 +130,7 @@ fn laid_out(shape: &[usize], texts: Vec<String>, text_layout: bool) -> String {
                         out.push('\n');
                     }
                     let start = p * plane_size + r * ncols;
-                    push_row(&mut out, &texts[start..start + ncols], &widths, text_layout);
+                    push_row(&mut out, &texts[start..start + ncols], &widths, cells);
                 }
             }
             out
@@ -257,19 +282,27 @@ fn column_widths(texts: &[String], ncols: usize) -> Vec<usize> {
     widths
 }
 
-fn push_row(out: &mut String, row: &[String], widths: &[usize], text_layout: bool) {
+fn push_row(out: &mut String, row: &[String], widths: &[usize], cells: Cells) {
     for (j, cell) in row.iter().enumerate() {
-        if text_layout {
+        if cells == Cells::Text {
             out.push_str(cell);
             continue;
         }
         if j > 0 {
             out.push(' ');
         }
-        for _ in 0..widths[j].saturating_sub(width(cell)) {
-            out.push(' ');
+        let pad = widths[j].saturating_sub(width(cell));
+        if cells == Cells::Right {
+            for _ in 0..pad {
+                out.push(' ');
+            }
         }
         out.push_str(cell);
+        if cells == Cells::Left {
+            for _ in 0..pad {
+                out.push(' ');
+            }
+        }
     }
 }
 
@@ -287,6 +320,8 @@ fn format_atom(data: &Data, i: usize, opts: &FmtOpts) -> String {
         Data::F64(v) => format_f64(v[i], opts),
         Data::Complex(v) => format_complex(v[i], opts),
         Data::Char(v) => v[i].to_string(),
+        // A symbol prints as its name behind the backtick that makes one.
+        Data::Symbol(v) => format!("`{}", crate::symbol::name(v[i])),
         // Boxed data takes the drawing path before reaching here.
         Data::Box(_) => String::new(),
     }

{libjay-0.2.0 → libjay-0.2.1}/crates/libjay/src/frontend/apl.rs

@@ -168,6 +168,11 @@ enum OpGlyph {
     Before,
     /// `⌸` key (Dyalog): each distinct major cell with what shares it.
     Key,
+    /// `.` between two functions: the inner product, `+.×` above all. The
+    /// operand on its right is a function too, as `∘.`'s is.
+    Dot,
+    /// `⍠` variant: one dialect knob overridden for this application.
+    Variant,
 }
 
 impl OpGlyph {
@@ -187,6 +192,8 @@ impl OpGlyph {
             OpGlyph::Each => '¨',
             OpGlyph::Before => '⍛',
             OpGlyph::Key => '⌸',
+            OpGlyph::Dot => '.',
+            OpGlyph::Variant => '⍠',
         }
     }
 }
@@ -667,7 +674,6 @@ fn quad_name(name: &str, d: Rules, span: Span) -> Result<Tok> {
 /// it under. These are queue positions, not unknown characters.
 fn queued_glyph(ch: char) -> Option<&'static str> {
     Some(match ch {
-        '⍠' => "the variant operator (f⍠v)",
         '⌶' => "I-beam (⌶)",
         // Dyalog's spawn. Named as a queue position rather than reported as
         // an unknown character; whether libjay's sandbox opens APL's
@@ -693,6 +699,10 @@ fn op_for(ch: char) -> Option<OpGlyph> {
         '¨' => Some(OpGlyph::Each),
         '⍛' => Some(OpGlyph::Before),
         '⌸' => Some(OpGlyph::Key),
+        '⍠' => Some(OpGlyph::Variant),
+        // A `.` that is not the start of a number and not the tail of `∘.`
+        // is the inner-product operator.
+        '.' => Some(OpGlyph::Dot),
         _ => None,
     }
 }
@@ -1252,7 +1262,10 @@ fn fold_operators(toks: Vec<Token>, d: Rules) -> Result<Vec<Token>> {
         }
         // `f∘g` and `f⍥g` need a function on both sides; the right one is
         // taken here so the ordinary "operand to the left" path can run.
-        if matches!(op, OpGlyph::Jot | OpGlyph::Over | OpGlyph::Before | OpGlyph::Under) {
+        if matches!(
+            op,
+            OpGlyph::Jot | OpGlyph::Over | OpGlyph::Before | OpGlyph::Under | OpGlyph::Dot
+        ) {
             let Some(gtok) = it.peek().filter(|x| matches!(x.kind, Tok::Func(_))) else {
                 return Err(Error::not_yet(
                     format!("{} with a value operand", op.glyph()),
@@ -1288,6 +1301,13 @@ fn fold_operators(toks: Vec<Token>, d: Rules) -> Result<Vec<Token>> {
                     let composed = Verb::Compose(Box::new(f), Box::new(g));
                     Verb::Atop(Box::new(back), Box::new(composed))
                 }
+                // `f.g` folds with f what g made of every row and column:
+                // `+.×` is the matrix product, `∧.=` asks which rows match.
+                OpGlyph::Dot => Verb::InnerProduct {
+                    u: Box::new(Verb::Reduce(Box::new(f))),
+                    v: Box::new(g),
+                    apl: true,
+                },
                 _ => Verb::Compose(Box::new(f), Box::new(g)),
             };
             out.push(Token { kind: Tok::Func(derived), span });
@@ -1315,6 +1335,8 @@ fn fold_operators(toks: Vec<Token>, d: Rules) -> Result<Vec<Token>> {
                     | OpGlyph::Stencil
                     | OpGlyph::Before
                     | OpGlyph::Key
+                    | OpGlyph::Dot
+                    | OpGlyph::Variant
                     | OpGlyph::Each => {
                         return Err(Error::parse(
                             format!("{} needs a function to its left", op.glyph()),
@@ -1375,6 +1397,19 @@ fn fold_operators(toks: Vec<Token>, d: Rules) -> Result<Vec<Token>> {
             }
             OpGlyph::Commute => Verb::Commute(Box::new(f)),
             OpGlyph::Key => Verb::KeyPairs(Box::new(f)),
+            // `f⍠B`: one setting of the dialect overridden for this
+            // application and no other.
+            OpGlyph::Variant => {
+                let (options, ospan) = variant_options(&mut it, t.span)?;
+                let derived = variant(f, &options, Span::merge(span, ospan))?;
+                out.push(Token { kind: Tok::Func(derived), span: Span::merge(span, ospan) });
+                continue;
+            }
+            // `.` reached with no function on its right: `+.` alone is not
+            // a function in either lineage.
+            OpGlyph::Dot => {
+                return Err(Error::parse("the inner product . needs a function on its right", t.span));
+            }
             // Each: the function runs on the contents of every item and
             // its result goes back into an item. A simple scalar result
             // stays simple, which is APL's enclosure rule.
@@ -1507,6 +1542,119 @@ fn take_axis(
     Ok(Some((k as usize, span)))
 }
 
+/// The options `⍠` was given, as `(name, value)` pairs.
+///
+/// A bare number is the PRINCIPAL option, which for every function libjay
+/// gives a variant is the comparison tolerance — so it arrives here named
+/// `CT`. The other published spelling is one or more parenthesised pairs,
+/// `⍠('IO' 0)` and `⍠('IO' 0)('CT' 0)`, whose halves are both literals.
+/// A computed option is a named gap: the variant is settled when the
+/// program is compiled, as the dialect it overrides is.
+fn variant_options(
+    it: &mut std::iter::Peekable<std::vec::IntoIter<Token>>,
+    span: Span,
+) -> Result<(Vec<(String, Array)>, Span)> {
+    if let Some(tok) = it.peek().filter(|t| literal(&t.kind).is_some()) {
+        let (value, vspan) = (literal(&tok.kind).expect("peeked a literal").clone(), tok.span);
+        it.next();
+        return Ok((vec![("CT".to_string(), value)], vspan));
+    }
+    let mut options = Vec::new();
+    let mut last = span;
+    while it.peek().is_some_and(|t| matches!(t.kind, Tok::LParen)) {
+        it.next();
+        let mut inside: Vec<Array> = Vec::new();
+        loop {
+            let Some(tok) = it.next() else {
+                return Err(Error::parse("unmatched ( after ⍠", span));
+            };
+            last = tok.span;
+            if matches!(tok.kind, Tok::RParen) {
+                break;
+            }
+            match literal(&tok.kind) {
+                Some(a) => inside.push(a.clone()),
+                None => {
+                    return Err(Error::not_yet(
+                        "a computed variant option (f⍠v with a name or an expression)",
+                        tok.span,
+                    ));
+                }
+            }
+        }
+        let [name, value] = inside.as_slice() else {
+            return Err(Error::parse("a variant option is a name and a value", last));
+        };
+        let Data::Char(cs) = &name.data else {
+            return Err(Error::parse("a variant option starts with its name", last));
+        };
+        options.push((cs.as_slice().iter().collect::<String>().to_uppercase(), value.clone()));
+    }
+    if options.is_empty() {
+        let where_ = it.peek().map_or(span, |t| t.span);
+        return Err(Error::not_yet(
+            "a computed variant option (f⍠v with a name or an expression)",
+            where_,
+        ));
+    }
+    Ok((options, last))
+}
+
+/// `f⍠B`: f with the dialect settings B names overridden for this
+/// application. `CT` is the comparison tolerance, which is the same
+/// mechanism J spells `!.`; `IO` is the index origin, which is resolved
+/// into the primitives when the program is compiled, so overriding it
+/// derives the verb again.
+fn variant(f: Verb, options: &[(String, Array)], span: Span) -> Result<Verb> {
+    let mut out = f;
+    for (name, value) in options {
+        out = match name.as_str() {
+            "CT" => {
+                let Some(ct) = value.to_f64_vec().and_then(|v| v.first().copied()) else {
+                    return Err(Error::domain("a comparison tolerance is a number", span));
+                };
+                if !out.uses_tolerance() {
+                    return Err(Error::domain(
+                        format!(
+                            "the comparison tolerance is not an option of {}: it consults none",
+                            out.name()
+                        ),
+                        span,
+                    ));
+                }
+                if !(0.0..1.0).contains(&ct) {
+                    return Err(Error::domain(
+                        "a comparison tolerance lies between 0 and 1",
+                        span,
+                    ));
+                }
+                Verb::Fit(Box::new(out), ct)
+            }
+            "IO" => {
+                let Some(io) = value.to_i64_vec().and_then(|v| v.first().copied()) else {
+                    return Err(Error::domain("an index origin is a whole number", span));
+                };
+                if io != 0 && io != 1 {
+                    return Err(Error::domain("an index origin is 0 or 1", span));
+                }
+                crate::verb::with_origin(&out, io).ok_or_else(|| {
+                    Error::domain(
+                        format!("the index origin is not an option of {}", out.name()),
+                        span,
+                    )
+                })?
+            }
+            other => {
+                return Err(Error::not_yet(
+                    format!("the variant option {other} (f⍠v)"),
+                    span,
+                ));
+            }
+        };
+    }
+    Ok(out)
+}
+
 /// `(/)` is `/`: parentheses around a bare operator glyph are transparent,
 /// so what decides the glyph's reading is the token outside them. The pair
 /// has no other meaning — an operator has no operand inside them — and the