fusion-lang 0.0.1.alpha2 → 0.0.1

data/lib/fusion/lexer.rb

@@ -15,9 +15,11 @@ module Fusion
       "[" => :lbracket, "]" => :rbracket,
       "{" => :lbrace, "}" => :rbrace,
       "," => :comma, ":" => :colon,
-      "|" => :pipe, "?" => :question, "." => :dot,
+      "?" => :question, "." => :dot,
       "@" => :at, "/" => :slash,
       "=" => :equals,
+      "+" => :plus, "-" => :minus, "*" => :star,
+      "%" => :percent, "~" => :tilde,
     }.freeze
 
     def initialize(src)
@@ -31,6 +33,11 @@ module Fusion
       loop do
         t = next_token
         out << t
+        # A file-reference path is one tight token, lexed only right after `@`/`@@`.
+        if t.type == :at || t.type == :atat
+          p = try_lex_path
+          out << p unless p.nil?
+        end
         break if t.type == :eof
       end
       out
@@ -55,6 +62,36 @@ module Fusion
         @i += 3
         return Token.new(type: :spread, value: "...", pos: start)
       end
+      if c == "@" && peek(1) == "@"
+        @i += 2
+        return Token.new(type: :atat, value: "@@", pos: start)
+      end
+      # Two-character operators, matched before their single-char prefixes.
+      if c == "=" && peek(1) == "="
+        @i += 2
+        return Token.new(type: :eqeq, value: "==", pos: start)
+      end
+      if c == "/" && peek(1) == "/"
+        @i += 2
+        return Token.new(type: :slashslash, value: "//", pos: start)
+      end
+      if c == "?" && peek(1) == "?"
+        @i += 2
+        return Token.new(type: :qq, value: "??", pos: start)
+      end
+      if c == "&" && peek(1) == "&"
+        @i += 2
+        return Token.new(type: :andand, value: "&&", pos: start)
+      end
+      if c == "|"
+        case peek(1)
+        when "|" then @i += 2; return Token.new(type: :oror, value: "||", pos: start)
+        when ":" then @i += 2; return Token.new(type: :pipemap, value: "|:", pos: start)
+        when "?" then @i += 2; return Token.new(type: :pipefilter, value: "|?", pos: start)
+        when "+" then @i += 2; return Token.new(type: :pipereduce, value: "|+", pos: start)
+        else @i += 1; return Token.new(type: :pipe, value: "|", pos: start)
+        end
+      end
       if c == "!"
         @i += 1
         return Token.new(type: :bang, value: "!", pos: start)
@@ -62,7 +99,7 @@ module Fusion
       if c == '"'
         return lex_string(start)
       end
-      if digit?(c) || (c == "-" && digit?(peek(1)))
+      if digit?(c)
         return lex_number(start)
       end
       if ident_start?(c)
@@ -143,7 +180,6 @@ module Fusion
 
     def lex_number(start)
       j = @i
-      j += 1 if @src[j] == "-"
       j += 1 while j < @n && digit?(@src[j])
       is_float = false
       if @src[j] == "." && digit?(@src[j + 1])
@@ -176,6 +212,36 @@ module Fusion
       end
     end
 
+    # Path lexing — see `tokens`. Only called immediately after `@`/`@@`, with no
+    # whitespace skipped, so the path must be tight. Returns nil (position restored)
+    # when nothing path-like follows, i.e. a bare `@`/`@@`.
+    def try_lex_path
+      start = @i
+      buf = +""
+      while peek == "." && peek(1) == "." && peek(2) == "/"
+        buf << "../"
+        @i += 3
+      end
+      unless ident_start?(peek)
+        @i = start
+        return nil
+      end
+      buf << lex_ident_text
+      while peek == "/" && ident_start?(peek(1))
+        @i += 1
+        buf << "/" << lex_ident_text
+      end
+      Token.new(type: :path, value: buf, pos: start)
+    end
+
+    def lex_ident_text
+      j = @i
+      j += 1 while j < @n && ident_part?(@src[j])
+      text = @src[@i...j]
+      @i = j
+      text
+    end
+
     def digit?(c) = c && c >= "0" && c <= "9"
     def ident_start?(c) = c && (c =~ /[A-Za-z_]/)
     def ident_part?(c) = c && (c =~ /[A-Za-z0-9_]/)

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)
+      Interpreter::ErrorVal.from_runtime(kind: "syntax_error", **site, operation: "parsing code", input: src, message: err.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)
+      Interpreter::ErrorVal.from_runtime(kind: "syntax_error", **site, operation: "parsing code", input: src, message: err.message)
     end
 
     # A leading `identifier =` marks a statement; anything else is an expression.
@@ -67,35 +67,136 @@ 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
+
+    # `??` (compare) is binary and left-associative — it does not fold.
+    def parse_ordering
+      node = parse_additive
+      while at?(:qq)
+        advance
+        node = pipe_operator([node, parse_additive], "compare")
+      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
+          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
-          Expression::ErrLit.new(payload: nil)            # bare ! -> !null
+          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 = %i[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 +212,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,6 +228,36 @@ 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
@@ -130,35 +268,34 @@ module Fusion
       when :lparen then parse_function_or_group
       when :ident then 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
@@ -275,7 +412,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
+    GUARDEDPAT_STARTERS = %i[number string true_kw false_kw null_kw minus
                              lbracket lbrace ident].freeze
 
     def parse_errpat
@@ -305,6 +442,7 @@ module Fusion
       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 :minus then advance; Pattern::PLit.new(value: -expect(:number).value)  # negative literal
       when :lbracket then parse_arraypat
       when :lbrace then parse_objectpat
       when :ident

data/lib/fusion/version.rb

@@ -1,3 +1,3 @@
 module Fusion
-  VERSION = "0.0.1.alpha2"
+  VERSION = "0.0.1"
 end

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\": _ ? @Array}", "{\"f\": _ ? @Function, \"c\": _ ? @Object}"]},
+)

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 | (
+    _ ? @falsey => {"f": f, "c": rest} | @,
+    _           => true,
+  ),
+  {"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\": _ ? @Array}", "{\"f\": _ ? @Function, \"c\": _ ? @Object}"]},
+)

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,6 @@
+# Drop null entries from an array (by element) or an object (by value). Built on @filter.
+(
+  xs ? @Array => {"f": (null => false, _ => true), "c": xs} | @filter,
+  obj ? @Object => {"f": (null => false, _ => true), "c": obj} | @filter,
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@compact", "status": 0, "input": x, "expected": ["_ ? @Array", "_ ? @Object"]}
+)

data/stdlib/concat.fsn

@@ -0,0 +1,5 @@
+# Concatenate two strings. Input: [a, b]. Built on @join with an empty separator.
+(
+  [a ? @String, b ? @String] => [[a, b], ""] | @join,
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@concat", "status": 0, "input": x, "expected": ["[_ ? @String, _ ? @String]"]}
+)

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} | @)],
+  ),
+  {"f": f ? @Function, "c": obj ? @Object} =>
+    {"f": (e => e | ([_, v] => v | f)), "c": {"f": (k => [k, obj[k]]), "c": obj | @keys} | @map} | @ | @toObject,
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@filter", "status": 0, "input": x, "expected": ["{\"f\": _ ? @Function, \"c\": _ ? @Array}", "{\"f\": _ ? @Function, \"c\": _ ? @Object}"]}
+)

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/gt.fsn

@@ -0,0 +1,9 @@
+# Strictly greater: interprets an @OP.compare result. Use as `[a, b] | @OP.compare | @gt`.
+# A partial order's compare may return null (incomparable); that propagates as null.
+(
+  -1 => false,
+  0 => false,
+  1 => true,
+  null => null,
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@gt", "status": 0, "input": x, "expected": ["-1", "0", "1", "null"]},
+)

data/stdlib/gte.fsn

@@ -0,0 +1,9 @@
+# Greater-or-equal: interprets an @OP.compare result. Use as `[a, b] | @OP.compare | @gte`.
+# A partial order's compare may return null (incomparable); that propagates as null.
+(
+  -1 => false,
+  0 => true,
+  1 => true,
+  null => null,
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@gte", "status": 0, "input": x, "expected": ["-1", "0", "1", "null"]},
+)

data/stdlib/lt.fsn

@@ -0,0 +1,9 @@
+# Strictly less: interprets an @OP.compare result. Use as `[a, b] | @OP.compare | @lt`.
+# A partial order's compare may return null (incomparable); that propagates as null.
+(
+  -1 => true,
+  0 => false,
+  1 => false,
+  null => null,
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@lt", "status": 0, "input": x, "expected": ["-1", "0", "1", "null"]},
+)

data/stdlib/lte.fsn

@@ -0,0 +1,9 @@
+# Less-or-equal: interprets an @OP.compare result. Use as `[a, b] | @OP.compare | @lte`.
+# A partial order's compare may return null (incomparable); that propagates as null.
+(
+  -1 => true,
+  0 => true,
+  1 => false,
+  null => null,
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@lte", "status": 0, "input": x, "expected": ["-1", "0", "1", "null"]},
+)

data/stdlib/map.fsn

@@ -1,6 +1,8 @@
+# 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} | @)],
+  {"f": f ? @Function, "c": obj ? @Object} => {"f": (k => [k, obj[k] | f]), "c": obj | @keys} | @ | @toObject,
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@map", "status": 0, "input": x, "expected": ["{\"f\": _ ? @Function, \"c\": _ ? @Array}", "{\"f\": _ ? @Function, \"c\": _ ? @Object}"]}
 )

data/stdlib/range.fsn

@@ -1,5 +1,5 @@
 (
   0 => [],
-  n ? (m ? @Integer => [-1, m] | @lessThan, _ => false) => [...([n, 1] | @subtract | @range), [n, 1] | @subtract],
-  x => !{"kind": "type_error", "location": "stdlib range.fsn", "operation": "range", "input": x | @sanitize, "message": "expected a non-negative integer"}
+  n ? (m ? @Integer => [m, 0] | @OP.compare | @gt) => [...([n, -1] | @OP.sum | @), [n, -1] | @OP.sum],
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@range", "status": 0, "input": x, "expected": ["_ ? (m ? @Integer => [m, 0] | @OP.compare | @gte)"]}
 )

data/stdlib/reduce.fsn

@@ -0,0 +1,8 @@
+# Left fold over a NON-EMPTY array with no seed: combine the first two elements
+# with f, then fold that result with the rest. Input: {"f": binaryFn, "c": array}.
+# `f` receives the pair [acc, element]. An empty list is an error.
+(
+  {"f": _ ? @Function, "c": [x]} => x,
+  {"f": f ? @Function, "c": [x, y, ...rest]} => {"f": f, "c": [[x, y] | f, ...rest]} | @,
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@reduce", "status": 0, "input": x, "expected": ["{\"f\": _ ? @Function, \"c\": [_, ...]}"]}
+)

data/stdlib/sanitize.fsn

@@ -6,7 +6,7 @@
 (
   v ? @Function => "<function>",
   v ? @NonFinite => [["<", v | @toString] | @concat, ">"] | @concat,
-  v ? @Array => {"f": @sanitize, "xs": v} | @map,
-  v ? @Object => {"f": @sanitize, "object": v} | @mapValues,
+  v ? @Array => {"f": @sanitize, "c": v} | @map,
+  v ? @Object => {"f": @sanitize, "c": v} | @map,
   v => v
 )

data/stdlib/truthy.fsn

@@ -0,0 +1,7 @@
+# True for every value except false and null — Fusion's own truthiness, decided by
+# pattern matching, so it is independent of any @OP override.
+(
+  false => false,
+  null => false,
+  _ => true,
+)