fusion-lang 0.0.1.alpha2 → 0.0.2

data/lib/fusion/parser.rb

@@ -22,16 +22,16 @@ module Fusion
 
     # Parse a complete program. The lexer and parser report failures by raising
     # ParseError; this single entry point rescues them and returns a standardized
-    # syntax_error value, so no caller ever sees a raw Ruby error. `location` is the
-    # syntax_error's "code X" / "code <inline>" context.
-    def self.parse_file(src, location:)
+    # syntax_error value, so no caller ever sees a raw Ruby error. `site` is the
+    # syntax_error's `{origin:, file:}` context.
+    def self.parse_file(src, site:)
       toks = Lexer.new(src).tokens
       p = new(toks)
       expr = p.parse_expr
       p.expect(:eof)
       expr
-    rescue ParseError => err
-      Interpreter::ErrorVal.internal(kind: "syntax_error", location: location, operation: "parsing", input: src, message: err.message)
+    rescue ParseError => e
+      Interpreter::ErrorVal.from_runtime(kind: "syntax_error", **site, operation: "parsing code", input: src, message: e.message)
     end
 
     # Parse one REPL entry — a statement (`identifier "=" expr`) or a bare
@@ -39,14 +39,14 @@ module Fusion
     # parse_file, a standardized syntax_error value instead of ever raising. The
     # REPL uses the error/non-error distinction to tell "keep editing" (didn't
     # parse yet) from "evaluate now" (a complete statement or expression).
-    def self.parse_repl(src, location:)
+    def self.parse_repl(src, site:)
       toks = Lexer.new(src).tokens
       p = new(toks)
       entry = p.parse_repl_entry
       p.expect(:eof)
       entry
-    rescue ParseError => err
-      Interpreter::ErrorVal.internal(kind: "syntax_error", location: location, operation: "parsing", input: src, message: err.message)
+    rescue ParseError => e
+      Interpreter::ErrorVal.from_runtime(kind: "syntax_error", **site, operation: "parsing code", input: src, message: e.message)
     end
 
     # A leading `identifier =` marks a statement; anything else is an expression.
@@ -67,35 +67,149 @@ module Fusion
     end
 
     def parse_expr
-      parse_pipe
+      parse_or
     end
 
-    def parse_pipe
-      left = parse_prefix
-      while at?(:pipe)
+    # --- Operator sugar (reference §2.7) --------------------------------------
+    # The ladder below desugars every operator to a pipe into an `@OP.*` member
+    # (or, for the map-pipes, a stdlib call). Tightest to loosest:
+    #   postfix · unary (! - / ~) · pipe (| |: |? |+) · * / % // · + - · ?? < <= > >= · == · && · ||
+    # `@OP.*` is a shadowable `:name` reference, so a local `@OP` reskins the operators.
+
+    def parse_or
+      operands = [parse_and]
+      while at?(:oror)
         advance
-        right = parse_prefix
-        left = Expression::Pipe.new(left: left, right: right)
+        operands << parse_and
       end
-      left
+      fold_operator(operands, "or")
     end
 
-    # Tokens that can begin a primary expression (used by parse_prefix to decide
-    # whether `!` is followed by an operand).
-    PRIMARY_STARTERS = %i[number string true_kw false_kw null_kw bang
-                          lbracket lbrace lparen ident at].freeze
+    def parse_and
+      operands = [parse_equality]
+      while at?(:andand)
+        advance
+        operands << parse_equality
+      end
+      fold_operator(operands, "and")
+    end
 
-    # `!` is a prefix operator that constructs an error from its operand. A bare
-    # `!` (no operand follows) is shorthand for `!null`. Binds tighter than `|`
-    # so `!x | f` is `(!x) | f`; looser than postfix so `!x.foo` is `!(x.foo)`.
-    def parse_prefix
-      if at?(:bang)
+    def parse_equality
+      operands = [parse_ordering]
+      while at?(:eqeq)
         advance
-        if PRIMARY_STARTERS.include?(peek.type)
-          Expression::ErrLit.new(payload: parse_prefix)   # allow !!x to nest
+        operands << parse_ordering
+      end
+      fold_operator(operands, "equal")
+    end
+
+    # The comparisons desugar to a compare piped into its reading member:
+    # `a < b` → `[a, b] | @OP.compare | @OP.lt`.
+    COMPARISON_MEMBERS = { lt: "lt", lte: "lte", gt: "gt", gte: "gte" }.freeze
+
+    # `??` (compare) and the comparisons are binary and left-associative — they
+    # do not fold, and `a < b < c` does not chain (it compares a boolean).
+    def parse_ordering
+      node = parse_additive
+      loop do
+        if at?(:qq)
+          advance
+          node = pipe_operator([node, parse_additive], "compare")
+        elsif COMPARISON_MEMBERS.key?(peek.type)
+          member = COMPARISON_MEMBERS[advance.type]
+          node = pipe_into(pipe_operator([node, parse_additive], "compare"), member)
+        else
+          break
+        end
+      end
+      node
+    end
+
+    # A run of `+`/`-` folds into one `@OP.sum`; each `-` term is negated.
+    def parse_additive
+      terms = [parse_multiplicative]
+      folded = false
+      while at?(:plus) || at?(:minus)
+        negated = at?(:minus)
+        advance
+        term = parse_multiplicative
+        terms << (negated ? negate(term) : term)
+        folded = true
+      end
+      folded ? pipe_operator(terms, "sum") : terms.first
+    end
+
+    # A run of `*`/`/` folds into one `@OP.product` (each `/` term inverted); `%`/`//`
+    # are binary and break the run. Standard left-to-right: `a * b % c` is `(a * b) % c`.
+    def parse_multiplicative
+      node = parse_pipe
+      run = nil # accumulating product-run terms, or nil
+      loop do
+        if at?(:star) || at?(:slash)
+          inverted = at?(:slash)
+          advance
+          term = parse_pipe
+          term = pipe_into(term, "invert") if inverted
+          if run
+            run << term
+          else
+            run = [node, term]
+          end
+        elsif at?(:percent) || at?(:slashslash)
+          node = pipe_operator(run, "product") if run
+          run = nil
+          op = at?(:percent) ? "modulo" : "quotient"
+          advance
+          node = pipe_operator([node, parse_pipe], op)
         else
-          Expression::ErrLit.new(payload: nil)            # bare ! -> !null
+          break
         end
+      end
+      run ? pipe_operator(run, "product") : node
+    end
+
+    def parse_pipe
+      node = parse_unary
+      loop do
+        if at?(:pipe)
+          advance
+          node = Expression::Pipe.new(left: node, right: parse_unary)
+        elsif at?(:pipemap) || at?(:pipefilter) || at?(:pipereduce)
+          target = { pipemap: "map", pipefilter: "filter", pipereduce: "reduce" }[peek.type]
+          advance
+          arg = Expression::ObjLit.new(
+            pairs: [
+              KeyValuePair.new(key: "c", value: node),
+              KeyValuePair.new(key: "f", value: parse_unary),
+            ],
+          )
+          node = Expression::Pipe.new(left: arg, right: name_ref(target))
+        else
+          break
+        end
+      end
+      node
+    end
+
+    # Tokens that can begin a unary operand — used to decide whether `!` has an
+    # operand or is the bare `!null`.
+    PRIMARY_STARTERS = [:number, :string, :true_kw, :false_kw, :null_kw, :bang, :minus, :slash, :tilde, :lbracket, :lbrace, :lparen, :ident, :at, :atat].freeze
+
+    # Unary prefixes: `!x` builds an error (bare `!` is `!null`); `-x` negates,
+    # `/x` inverts, `~x` is logical not. All bind tighter than `|`.
+    def parse_unary
+      if at?(:bang)
+        advance
+        PRIMARY_STARTERS.include?(peek.type) ? Expression::ErrLit.new(payload: parse_unary) : Expression::ErrLit.new(payload: nil)
+      elsif at?(:minus)
+        advance
+        negate(parse_unary)
+      elsif at?(:slash)
+        advance
+        pipe_into(parse_unary, "invert")
+      elsif at?(:tilde)
+        advance
+        pipe_into(parse_unary, "not")
       else
         parse_postfix
       end
@@ -111,8 +225,15 @@ module Fusion
         elsif at?(:lbracket)
           advance
           idx = parse_expr
-          expect(:rbracket)
-          node = Expression::Index.new(obj: node, idx: idx)
+          if at?(:equals)
+            advance
+            value = parse_expr
+            expect(:rbracket)
+            node = Expression::IndexSet.new(obj: node, idx: idx, value: value)
+          else
+            expect(:rbracket)
+            node = Expression::Index.new(obj: node, idx: idx)
+          end
         else
           break
         end
@@ -120,45 +241,78 @@ module Fusion
       node
     end
 
+    # --- Desugaring helpers ---------------------------------------------------
+
+    def name_ref(path) = Expression::FileRef.new(variety: :name, path: path)
+
+    # `@OP.member`, a shadowable reference.
+    def op_member(member) = Expression::Member.new(obj: name_ref("OP"), key: member)
+
+    # `expr | @OP.member`
+    def pipe_into(expr, member) = Expression::Pipe.new(left: expr, right: op_member(member))
+
+    # `[operands...] | @OP.member`
+    def pipe_operator(operands, member)
+      arr = Expression::ArrLit.new(items: operands.map { |e| ArrayItem.new(value: e) })
+      Expression::Pipe.new(left: arr, right: op_member(member))
+    end
+
+    # A single-operand run collapses to that operand; otherwise fold n-ary.
+    def fold_operator(operands, member)
+      operands.length == 1 ? operands.first : pipe_operator(operands, member)
+    end
+
+    # `-x`: a numeric literal folds to a negative literal; anything else negates.
+    def negate(expr)
+      if expr.is_a?(Expression::Lit) && expr.value.is_a?(Numeric)
+        Expression::Lit.new(value: -expr.value)
+      else
+        pipe_into(expr, "negate")
+      end
+    end
+
     def parse_primary
       t = peek
       case t.type
-      when :number, :string then advance; Expression::Lit.new(value: t.value)
-      when :true_kw, :false_kw, :null_kw then advance; Expression::Lit.new(value: t.value)
+      when :number, :string, :true_kw, :false_kw, :null_kw
+        advance
+        Expression::Lit.new(value: t.value)
       when :lbracket then parse_array
       when :lbrace then parse_object
       when :lparen then parse_function_or_group
-      when :ident then advance; Expression::Ident.new(name: t.value)
+      when :ident
+        advance
+        Expression::Ident.new(name: t.value)
       when :at then parse_fileref
+      when :atat then parse_superref
       else raise ParseError, "Unexpected token #{t.type} (#{t.value.inspect}) at #{t.pos}"
       end
     end
 
+    # `@@` is super. Bare `@@` is super of the current file's own name; `@@name`
+    # (or a downward `@@dir/name`) is a *stable* reference to that name — it skips
+    # the sibling `name.fsn`, resolving builtin → stdlib, so a user's local shadow
+    # can't intercept it. `@@../…` is meaningless (super of an upward path) and
+    # falls through to a parse error.
+    def parse_superref
+      expect(:atat)
+      return Expression::FileRef.new(variety: :super, path: nil) unless at?(:path)
+
+      tok = advance
+      raise ParseError, "`@@` cannot take an upward path (at #{tok.pos})" if tok.value.include?("..")
+
+      Expression::FileRef.new(variety: :super_name, path: tok.value)
+    end
+
     def parse_fileref
       expect(:at)
-      # Bare "@" = current file: not followed by something that can begin a path.
-      nxt = peek
-      starts_path = (nxt.type == :ident) || (nxt.type == :dot && peek(1)&.type == :dot)
-      return Expression::FileRef.new(variety: :self, path: nil) unless starts_path
-      # refpath: { "../" } segment { "/" segment }
-      parts = []
-      has_dotdot = false
-      while at?(:dot) && peek(1)&.type == :dot
-        advance; advance # consume the two dots of ..
-        parts << ".."
-        expect(:slash)
-        has_dotdot = true
-      end
-      parts << expect(:ident).value
-      while at?(:slash)
-        advance
-        parts << expect(:ident).value
-      end
-      # A reference is eligible for builtin/stdlib fallback (:name) iff it does NOT
-      # contain "../". Downward paths like "dir/a" are still eligible; only "../"
-      # (escaping upward) forces pure file-path (:path) resolution.
-      bare = !has_dotdot
-      Expression::FileRef.new(variety: bare ? :name : :path, path: parts.join("/"))
+      return Expression::FileRef.new(variety: :self, path: nil) unless at?(:path)
+
+      # A reference is eligible for builtin/stdlib fallback (:name) iff it has no
+      # "../"; downward paths stay eligible, only "../" forces file-only (:path).
+      # The lexer produced the whole path as one tight token (see Lexer#try_lex_path).
+      path = advance.value
+      Expression::FileRef.new(variety: path.include?("..") ? :path : :name, path: path)
     end
 
     def parse_array
@@ -172,6 +326,7 @@ module Fusion
           items << ArrayItem.new(value: parse_expr)
         end
         break unless at?(:comma)
+
         advance
       end
       expect(:rbracket)
@@ -192,11 +347,13 @@ module Fusion
           key_tok = expect(:string)
           key = key_tok.value
           raise ParseError, "duplicate key #{key.inspect} (at #{key_tok.pos})" if keys.include?(key)
+
           keys << key
           expect(:colon)
           pairs << KeyValuePair.new(key: key, value: parse_expr)
         end
         break unless at?(:comma)
+
         advance
       end
       expect(:rbrace)
@@ -221,12 +378,11 @@ module Fusion
           expect(:arrow)
           body = parse_expr
           clauses << Clause.new(pattern: pat, body: body)
-          if at?(:comma)
-            advance
-            break if at?(:rparen) # trailing comma
-          else
-            break
-          end
+
+          break if !at?(:comma)
+
+          advance
+          break if at?(:rparen) # trailing comma
         end
         expect(:rparen)
         Expression::FuncLit.new(clauses: clauses)
@@ -247,10 +403,11 @@ module Fusion
         case t.type
         when :lparen, :lbracket, :lbrace then depth += 1
         when :rparen, :rbracket, :rbrace
-          return false if depth.zero? # hit our closing ) first
+          return false if depth == 0 # hit our closing ) first
+
           depth -= 1
         when :arrow
-          return true if depth.zero?
+          return true if depth == 0
         when :eof
           return false
         end
@@ -275,8 +432,7 @@ module Fusion
 
     # Tokens that can begin a `guardedpat` (used to detect whether `!` is
     # followed by a payload pattern or stands alone).
-    GUARDEDPAT_STARTERS = %i[number string true_kw false_kw null_kw
-                             lbracket lbrace ident].freeze
+    GUARDEDPAT_STARTERS = [:number, :string, :true_kw, :false_kw, :null_kw, :minus, :lbracket, :lbrace, :ident].freeze
 
     def parse_errpat
       expect(:bang)
@@ -303,8 +459,12 @@ module Fusion
     def parse_corepat
       t = peek
       case t.type
-      when :number, :string then advance; Pattern::PLit.new(value: t.value)
-      when :true_kw, :false_kw, :null_kw then advance; Pattern::PLit.new(value: t.value)
+      when :number, :string, :true_kw, :false_kw, :null_kw
+        advance
+        Pattern::PLit.new(value: t.value)
+      when :minus
+        advance
+        Pattern::PLit.new(value: -expect(:number).value) # negative literal
       when :lbracket then parse_arraypat
       when :lbrace then parse_objectpat
       when :ident
@@ -335,12 +495,14 @@ module Fusion
             advance
             break if at?(:rbracket) # trailing comma
             raise ParseError, "a pattern may contain at most one `...rest` (at #{peek.pos})" if at?(:spread)
+
             items << PatternItem.new(pattern: parse_guardedpat)
           end
           break
         end
         items << PatternItem.new(pattern: parse_guardedpat)
         break unless at?(:comma)
+
         advance
       end
       expect(:rbracket)
@@ -361,14 +523,17 @@ module Fusion
           unless at?(:rbrace)
             raise ParseError, "in an object pattern, `...rest` must come last (at #{peek.pos})"
           end
+
           break
         end
         key_pos = peek.pos
         pair = parse_pattern_pair
         raise ParseError, "duplicate key #{pair.key.inspect} (at #{key_pos})" if keys.include?(pair.key)
+
         keys << pair.key
         pairs << pair
         break unless at?(:comma)
+
         advance
       end
       expect(:rbrace)
@@ -392,12 +557,22 @@ module Fusion
     end
 
     # ---- token helpers ----
-    def peek(o = 0) = @toks[@i + o]
-    def at?(type) = peek.type == type
-    def advance = (@toks[@i].tap { @i += 1 })
+    def peek(o = 0)
+      @toks[@i + o]
+    end
+
+    def at?(type)
+      peek.type == type
+    end
+
+    def advance
+      @toks[@i].tap { @i += 1 }
+    end
+
     def expect(type)
       t = peek
       raise ParseError, "Expected #{type} but got #{t.type} (#{t.value.inspect}) at #{t.pos}" unless t.type == type
+
       advance
     end
   end

data/lib/fusion/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Fusion
-  VERSION = "0.0.1.alpha2"
+  VERSION = "0.0.2"
 end

data/lib/fusion.rb

@@ -1,4 +1,3 @@
-#!/usr/bin/env ruby
 # frozen_string_literal: true
 
 # Fusion — a proof-of-concept interpreter.

data/stdlib/all.fsn

@@ -0,0 +1,13 @@
+# Return true if every item satisfies the predicate "f" (a truthy result) — over an
+# array's elements or an object's values. Input: {"f": predicate, "c": array-or-object}.
+# Short-circuits: the first item whose predicate is falsey yields false without testing
+# the rest.
+(
+  {"f": _ ? @Function, "c": []} => true,
+  {"f": f ? @Function, "c": [x, ...rest]} => x | f | (
+    _ ? @falsey => false,
+    _           => {"f": f, "c": rest} | @,
+  ),
+  {"f": f ? @Function, "c": obj ? @Object} => {"f": f, "c": obj | @values} | @,
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@all", "status": 0, "input": x, "expected": ["{\"f\": _ ? @Function, \"c\": _ ? @Collection}"]},
+)

data/stdlib/any.fsn

@@ -0,0 +1,12 @@
+# True if any item satisfies the predicate — over an array's elements or an object's
+# values. Input: {"f": predicate, "c": array-or-object}. Short-circuits on the first
+# truthy result.
+(
+  {"f": _ ? @Function, "c": []} => false,
+  {"f": f ? @Function, "c": [x, ...rest]} => x | f | (
+    _ ? @truthy => true,
+    _           => {"f": f, "c": rest} | @,
+  ),
+  {"f": f ? @Function, "c": obj ? @Object} => {"f": f, "c": obj | @values} | @,
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@any", "status": 0, "input": x, "expected": ["{\"f\": _ ? @Function, \"c\": _ ? @Collection}"]},
+)

data/stdlib/chars.fsn

@@ -0,0 +1,5 @@
+# Split a string into its characters. Built on @split with an empty separator.
+(
+  s ? @String => [s, ""] | @split,
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@chars", "status": 0, "input": x, "expected": ["_ ? @String"]}
+)

data/stdlib/compact.fsn

@@ -0,0 +1,5 @@
+# Drop null entries from an array (by element) or an object (by value). Built on @filter.
+(
+  c ? @Collection => c |? (null => false, _ => true),
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@compact", "status": 0, "input": x, "expected": ["_ ? @Collection"]}
+)

data/stdlib/concat.fsn

@@ -0,0 +1,6 @@
+# Concatenate an array of strings, of any length. Built on @join with an empty
+# separator.
+(
+  strings ? (xs ? @Array => {"c": xs, "f": @String} | @all) => [strings, ""] | @join,
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@concat", "status": 0, "input": x, "expected": ["_ ? (xs ? @Array => {\"c\": xs, \"f\": @String} | @all)"]}
+)

data/stdlib/entries.fsn

@@ -0,0 +1,6 @@
+# Destructure an object into an array of its [key, value] entries, in insertion
+# order. The inverse of @toObject.
+(
+  obj ? @Object => obj | @keys |: (k => [k, obj[k]]),
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@entries", "status": 0, "input": x, "expected": ["_ ? @Object"]}
+)

data/stdlib/falsey.fsn

@@ -0,0 +1,6 @@
+# True for false and null — Fusion's own falsiness, decided by pattern matching.
+(
+  false => true,
+  null => true,
+  _ => false,
+)

data/stdlib/filter.fsn

@@ -0,0 +1,12 @@
+# Keep the array elements (or object values) for which f(x) is truthy. Input:
+# {"f": predicate, "c": array-or-object}. Like @map, it is polymorphic on c.
+(
+  {"f": _ ? @Function, "c": []} => [],
+  {"f": f ? @Function, "c": [x, ...rest]} => x | f | (
+    _ ? @falsey => {"f": f, "c": rest} | @,
+    _           => [x, ...({"f": f, "c": rest} | @)],
+  ),
+  # Reduce to array case
+  {"f": f ? @Function, "c": obj ? @Object} => {"f": ([_, v] => v | f), "c": obj | @entries} | @ | @toObject,
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@filter", "status": 0, "input": x, "expected": ["{\"f\": _ ? @Function, \"c\": _ ? @Collection}"]}
+)

data/stdlib/flatten.fsn

@@ -0,0 +1,7 @@
+# Recursively flatten nested arrays into one flat array.
+(
+  [] => [],
+  [x ? @Array, ...rest] => [...(x | @), ...(rest | @)],
+  [x, ...rest] => [x, ...(rest | @)],
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@flatten", "status": 0, "input": x, "expected": ["_ ? @Array"]}
+)

data/stdlib/map.fsn

@@ -1,6 +1,9 @@
+# Apply f to each element of an array, or to each value of an object (keeping the
+# keys). Input: {"f": fn, "c": array-or-object}.
 (
-  {"f": _, "xs": []} => [],
-  {"f": f, "xs": [x, ...rest]} => [x | f, ...({"f": f, "xs": rest} | @map)],
-  {"f": _, "xs": xs} => !{"kind": "type_error", "location": "stdlib map.fsn", "operation": "map", "input": xs | @sanitize, "message": "expected an array"},
-  x => !{"kind": "argument_error", "location": "stdlib map.fsn", "operation": "map", "input": x | @sanitize, "message": "expected {\"f\": _, \"xs\": _}"}
+  {"f": _ ? @Function, "c": []} => [],
+  {"f": f ? @Function, "c": [x, ...rest]} => [x | f, ...({"f": f, "c": rest} | @)],
+  # Reduce to array case
+  {"f": f ? @Function, "c": obj ? @Object} => {"f": ([k, v] => [k, v | f]), "c": obj | @entries} | @ | @toObject,
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@map", "status": 0, "input": x, "expected": ["{\"f\": _ ? @Function, \"c\": _ ? @Collection}"]}
 )

data/stdlib/matrix/Matrix.fsn

@@ -0,0 +1,8 @@
+# True for a matrix: a non-empty array of equally sized vectors (@vector/Vector).
+# A predicate: false for anything else, never an error.
+(rows => [
+  rows | @Array,
+  rows | @size > 0,
+  {"c": rows, "f": @vector/Vector} | @all,
+  rows |: @size | @OP.equal,
+] | @OP.and | @safe)

data/stdlib/matrix/OP.fsn

@@ -0,0 +1,18 @@
+# The operators reskinned for matrices. Point a directory's OP.fsn at
+# `@matrix/OP` to make the arithmetic sugar operate on matrices: `a + b`
+# (elementwise sum), `-a` / `a - b` (elementwise negation), `a * b` (matrix
+# product), `/a` (inverse), `a / b` (multiply by the inverse). `//` and `%`
+# have no matrix meaning and always raise. The spread keeps every other member
+# (equal, compare and its readers, the boolean operators) at its builtin
+# meaning — this module's own files rely on that: they use the comparison and
+# boolean sugar and plain `@OP` references freely, and reserve `@@OP` for the
+# scalar versions of the arithmetic members this file overrides.
+{
+  ...@@,
+  "sum": @sum,
+  "negate": @negate,
+  "product": @product,
+  "invert": @invert,
+  "quotient": (x => !{"kind": "math_error", "origin": "stdlib", "operation": "@matrix/OP.quotient", "status": 0, "input": x, "message": "integer division is not defined for matrices"}),
+  "modulo": (x => !{"kind": "math_error", "origin": "stdlib", "operation": "@matrix/OP.modulo", "status": 0, "input": x, "message": "modulo is not defined for matrices"}),
+}

data/stdlib/matrix/add.fsn

@@ -0,0 +1,7 @@
+# Add two equally sized matrices elementwise: zip the rows and add each pair
+# through @vector/add. Input: [a, b].
+(
+  [a, b] ? ([x ? @Matrix, y ? @Matrix] => [x, y] |: @dimensions | @OP.equal) =>
+    [a, b] | @zip |: @vector/add,
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@matrix/add", "status": 0, "input": x, "expected": ["_ ? ([a ? @matrix/Matrix, b ? @matrix/Matrix] => [a, b] |: @matrix/dimensions | @OP.equal)"]}
+)

data/stdlib/matrix/column.fsn

@@ -0,0 +1,6 @@
+# Extract the i-th (0-based) column of a matrix as a vector. Input: [matrix, index].
+(
+  [m, i] ? ([x ? @Matrix, n ? @Integer] => n >= 0 && n < (x | @dimensions).columns) =>
+    m |: (row => row[i]),
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@matrix/column", "status": 0, "input": x, "expected": ["_ ? ([m ? @matrix/Matrix, i ? @Integer] => i >= 0 && i < (m | @matrix/dimensions).columns)"]}
+)

data/stdlib/matrix/determinant.fsn

@@ -0,0 +1,16 @@
+# Determinant of a square matrix, by Laplace expansion along the first row: the
+# dot product of the first row with its cofactors (signed minor determinants).
+(
+  m ? (sq ? @Matrix => sq | @dimensions | (d => d.rows == d.columns)) =>
+    m | (
+      [[a]] => a,
+      [firstRow, ...] =>
+        [
+          firstRow,
+          (m | @dimensions).columns | @range |: (j =>
+            [[-1, j] | @math.pow, [m, 0, j] | @minor | @] | @@OP.product
+          ),
+        ] | @vector/dot
+    ),
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@matrix/determinant", "status": 0, "input": x, "expected": ["_ ? (sq ? @matrix/Matrix => sq | @matrix/dimensions | (d => d.rows == d.columns))"]}
+)

data/stdlib/matrix/dimensions.fsn

@@ -0,0 +1,5 @@
+# The dimensions of a matrix, as {"rows": _, "columns": _}.
+(
+  m ? @Matrix => {"rows": m | @size, "columns": m[0] | @size},
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@matrix/dimensions", "status": 0, "input": x, "expected": ["_ ? @matrix/Matrix"]}
+)