fusion-lang 0.0.1 → 0.0.2

data/lib/fusion/interpreter.rb

@@ -80,10 +80,10 @@ module Fusion
     rescue Unreachable
       # An interpreter bug. Allowed to surface.
       raise
-    rescue StandardError => err
+    rescue StandardError => e
       Interpreter::ErrorVal.from_runtime(
         kind: "internal_error", origin: "interpreter", operation: "running the program",
-        input: NULL, message: err.message
+        input: NULL, message: e.message,
       )
     rescue SystemExit
       # Let exit/abort through.
@@ -91,13 +91,13 @@ module Fusion
     rescue SystemStackError
       Interpreter::ErrorVal.from_runtime(
         kind: "limit_error", origin: "interpreter", operation: "running the program",
-        input: NULL, message: "stack level too deep"
+        input: NULL, message: "stack level too deep",
       )
-    rescue Exception => err # rubocop:disable Lint/RescueException
+    rescue Exception => e # rubocop:disable Lint/RescueException
       # Final net: any other escaped Ruby error becomes a payloaded error too.
       Interpreter::ErrorVal.from_runtime(
         kind: "internal_error", origin: "interpreter", operation: "running the program",
-        input: NULL, message: err.message
+        input: NULL, message: e.message,
       )
     end
 
@@ -169,9 +169,9 @@ module Fusion
       end
     rescue Errno::ENOENT
       raise Thunk::ReadFailure, "file not found"
-    rescue SystemCallError => err # EISDIR, EACCES, ... (file-system access failures)
+    rescue SystemCallError => e # EISDIR, EACCES, ... (file-system access failures)
       # Drop Ruby's "@ io_fread - <path>" tail.
-      raise Thunk::ReadFailure, err.message.split(" @ ").first.downcase
+      raise Thunk::ReadFailure, e.message.split(" @ ").first.downcase
     end
 
     # Evaluate a top-level unit that has no file of its own:
@@ -191,7 +191,7 @@ module Fusion
     # `site` is the `{origin:, file:}` of the referencing code; `reference` is its
     # own source text (`"@name"`) — the single `operation` every failure reports.
     def resolve_name(name, dir, site, reference)
-      sibling_file = File.expand_path(name + ".fsn", dir)
+      sibling_file = File.expand_path("#{name}.fsn", dir)
       if File.exist?(sibling_file)
         return jail_error(site, reference, NULL) unless within_jail?(sibling_file)
 
@@ -251,7 +251,7 @@ module Fusion
         return @builtins[name]
       end
 
-      stdlib_file = File.join(@stdlib_dir, name + ".fsn")
+      stdlib_file = File.join(@stdlib_dir, "#{name}.fsn")
       if File.exist?(stdlib_file)
         # The reference reports the user's source text, not the internal stdlib path.
         return load_file(stdlib_file).force(operation: reference, input: NULL, site: site)
@@ -263,7 +263,7 @@ module Fusion
     # Resolve a pure path "@dir/a" or "@../a": file only, never builtin/stdlib.
     # `reference` is the source text (`"@../a"`), the single `operation` reported.
     def resolve_path(relpath, dir, site, reference)
-      target = File.expand_path(relpath + ".fsn", dir)
+      target = File.expand_path("#{relpath}.fsn", dir)
       return jail_error(site, reference, NULL) unless within_jail?(target)
 
       load_file(target).force(operation: reference, input: NULL, site: site)
@@ -374,11 +374,11 @@ module Fusion
         when ArrayItem
           out.append(value)
         when ArraySpread
-          if value.is_a?(Array)
-            out.concat(value)
-          else
+          if !value.is_a?(Array)
             return ErrorVal.from_runtime(kind: "argument_error", **code_site(env), operation: "[...] array spread", input: value, expected: ["_ ? @Array"])
           end
+
+          out.concat(value)
         else
           raise Unreachable, "Unknown array item #{item.class}"
         end
@@ -402,11 +402,11 @@ module Fusion
         when KeyValuePair
           out[pair.key] = value
         when ObjectSpread
-          if value.is_a?(Hash)
-            out.merge!(value)
-          else
+          if !value.is_a?(Hash)
             return ErrorVal.from_runtime(kind: "argument_error", **code_site(env), operation: "{...} object spread", input: value, expected: ["_ ? @Object"])
           end
+
+          out.merge!(value)
         else
           raise Unreachable, "Unknown object pair #{pair.class}"
         end
@@ -535,16 +535,21 @@ module Fusion
         # becomes a payloaded error rather than a raw backtrace on stderr.
         begin
           f.fn.call(v)
-        rescue StandardError => err
+        rescue StandardError => e
           # TODO: move math errors into the builtins. This should become a safety net for unpredicted errors.
-          kind = (err.is_a?(FloatDomainError) || err.is_a?(ZeroDivisionError) || err.is_a?(Math::DomainError)) ? "math_error" : "internal_error"
-          ErrorVal.from_runtime(kind: kind, origin: "builtin", operation: "@#{f.name}", input: v, message: err.message)
+          kind = case e
+          when FloatDomainError, ZeroDivisionError, Math::DomainError
+            "math_error"
+          else
+            "internal_error"
+          end
+          ErrorVal.from_runtime(kind: kind, origin: "builtin", operation: "@#{f.name}", input: v, message: e.message)
         end
       elsif f.is_a?(Func)
         # Stdlib code has no user file of its own: errors inside it (and in the
         # built-ins it calls) report the user `call_site` that reached it. User and
         # inline functions are their own call site (derived lexically from their env).
-        body_call_site = (code_site(f.env)[:origin] == "stdlib") ? call_site : nil
+        body_call_site = code_site(f.env)[:origin] == "stdlib" ? call_site : nil
 
         f.clauses.each do |clause|
           # Bindings are inserted directly into a fresh child env as the pattern
@@ -646,7 +651,7 @@ module Fusion
           if predicate_result.is_a?(ErrorVal)
             # An unresolved @-reference, or an error raised while applying the
             # predicate, becomes the clause's result.
-            return predicate_result
+            predicate_result
           else
             # Ruby-style truthiness: the clause matches unless the predicate
             # yields `false` or `null`.
@@ -672,11 +677,11 @@ module Fusion
           return r if r.is_a?(ErrorVal)
           return false unless r
         end
-        true
       else
         before = items[0...rest_index]
         after  = items[(rest_index + 1)..]
         return false if value.length < before.length + after.length
+
         before.each_with_index do |item, i|
           r = match(item.pattern, value[i], env)
           return r if r.is_a?(ErrorVal)
@@ -693,8 +698,8 @@ module Fusion
           mid = value[before.length...(value.length - after.length)]
           env.bind(rest_name, mid)
         end
-        true
       end
+      true
     end
 
     def match_object(pattern, value, env)
@@ -708,9 +713,11 @@ module Fusion
           rest_name = pair.name # may be nil (ignore) or a string
         when PatternPair
           return false unless value.key?(pair.key)
+
           r = match(pair.pattern, value[pair.key], env)
           return r if r.is_a?(ErrorVal)
           return false unless r
+
           matched_keys << pair.key
         else
           raise Unreachable, "Unknown object pattern pair #{pair.class}"
@@ -739,6 +746,7 @@ module Fusion
     def deep_equal?(a, b)
       return true if a.equal?(b)
       return false if a.class != b.class
+
       case a
       when Array
         a.length == b.length && a.each_index.all? { |i| deep_equal?(a[i], b[i]) }

data/lib/fusion/lexer.rb

@@ -20,6 +20,7 @@ module Fusion
       "=" => :equals,
       "+" => :plus, "-" => :minus, "*" => :star,
       "%" => :percent, "~" => :tilde,
+      "<" => :lt, ">" => :gt,
     }.freeze
 
     def initialize(src)
@@ -34,7 +35,7 @@ module Fusion
         t = next_token
         out << t
         # A file-reference path is one tight token, lexed only right after `@`/`@@`.
-        if t.type == :at || t.type == :atat
+        if [:at, :atat].include?(t.type)
           p = try_lex_path
           out << p unless p.nil?
         end
@@ -79,17 +80,35 @@ module Fusion
         @i += 2
         return Token.new(type: :qq, value: "??", pos: start)
       end
+      if c == "<" && peek(1) == "="
+        @i += 2
+        return Token.new(type: :lte, value: "<=", pos: start)
+      end
+      if c == ">" && peek(1) == "="
+        @i += 2
+        return Token.new(type: :gte, 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)
+        when "|"
+          @i += 2
+          return Token.new(type: :oror, value: "||", pos: start)
+        when ":"
+          @i += 2
+          return Token.new(type: :pipemap, value: "|:", pos: start)
+        when "?"
+          @i += 2
+          return Token.new(type: :pipefilter, value: "|?", pos: start)
+        when "+"
+          @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 == "!"
@@ -105,6 +124,7 @@ module Fusion
       if ident_start?(c)
         return lex_word(start)
       end
+
       if (type = PUNCT[c])
         @i += 1
         return Token.new(type: type, value: c, pos: start)
@@ -114,13 +134,13 @@ module Fusion
 
     def skip_trivia
       loop do
-        c = peek
-        if c == " " || c == "\t" || c == "\n" || c == "\r"
+        case peek
+        when " ", "\t", "\n", "\r"
           @i += 1
-        elsif c == "#" && at_line_start?
-          # A line is a comment iff its first non-whitespace char is "#".
-          # This also covers shebang lines (#!) for free.
-          @i += 1 until peek.nil? || peek == "\n"
+        when "#"
+          break if !at_line_start?
+
+          @i += 1 until [nil, "\n"].include?(peek)
         else
           break
         end
@@ -130,7 +150,7 @@ module Fusion
     # True when only whitespace precedes @i on the current physical line.
     def at_line_start?
       j = @i - 1
-      j -= 1 while j >= 0 && (@src[j] == " " || @src[j] == "\t")
+      j -= 1 while j >= 0 && [" ", "\t"].include?(@src[j])
       j < 0 || @src[j] == "\n" || @src[j] == "\r"
     end
 
@@ -138,37 +158,39 @@ module Fusion
       @i += 1 # opening quote
       buf = +""
       while (c = peek)
-        if c == '"'
+        case c
+        when '"'
           @i += 1
           return Token.new(type: :string, value: buf, pos: start)
-        elsif c == "\\"
+        when "\\"
           @i += 1
           e = peek
           buf << case e
-                 when '"' then '"'
-                 when "\\" then "\\"
-                 when "/" then "/"
-                 when "n" then "\n"
-                 when "t" then "\t"
-                 when "r" then "\r"
-                 when "b" then "\b"
-                 when "f" then "\f"
-                 when "u"
-                   hex = @src[@i + 1, 4]
-                   @i += 4
-                   code_point = hex.to_i(16)
-                   # Reject surrogates and out-of-range code points up front:
-                   # pack("U") would otherwise build an invalid-encoding string
-                   # whose malformed-UTF-8 error surfaces far downstream.
-                   if code_point.between?(0xD800, 0xDFFF) || code_point > 0x10FFFF
-                     raise ParseError, "Invalid unicode escape \\u#{hex}"
-                   end
-                   [code_point].pack("U")
-                 else
-                   raise ParseError, "Bad escape \\#{e}"
-                 end
+          when '"' then '"'
+          when "\\" then "\\"
+          when "/" then "/"
+          when "n" then "\n"
+          when "t" then "\t"
+          when "r" then "\r"
+          when "b" then "\b"
+          when "f" then "\f"
+          when "u"
+            hex = @src[@i + 1, 4]
+            @i += 4
+            code_point = hex.to_i(16)
+            # Reject surrogates and out-of-range code points up front:
+            # pack("U") would otherwise build an invalid-encoding string
+            # whose malformed-UTF-8 error surfaces far downstream.
+            if code_point.between?(0xD800, 0xDFFF) || code_point > 0x10FFFF
+              raise ParseError, "Invalid unicode escape \\u#{hex}"
+            end
+
+            [code_point].pack("U")
+          else
+            raise ParseError, "Bad escape \\#{e}"
+          end
           @i += 1
-        elsif c == "\n" || c == "\r"
+        when "\n", "\r"
           raise ParseError, "Raw newline in string starting at #{start}; use \\n"
         else
           buf << c
@@ -187,10 +209,10 @@ module Fusion
         j += 1
         j += 1 while j < @n && digit?(@src[j])
       end
-      if (@src[j] == "e" || @src[j] == "E")
+      if ["e", "E"].include?(@src[j])
         is_float = true
         j += 1
-        j += 1 if (@src[j] == "+" || @src[j] == "-")
+        j += 1 if ["+", "-"].include?(@src[j])
         j += 1 while j < @n && digit?(@src[j])
       end
       text = @src[@i...j]

data/lib/fusion/parser.rb

@@ -30,8 +30,8 @@ module Fusion
       expr = p.parse_expr
       p.expect(:eof)
       expr
-    rescue ParseError => err
-      Interpreter::ErrorVal.from_runtime(kind: "syntax_error", **site, operation: "parsing code", 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
@@ -45,8 +45,8 @@ module Fusion
       entry = p.parse_repl_entry
       p.expect(:eof)
       entry
-    rescue ParseError => err
-      Interpreter::ErrorVal.from_runtime(kind: "syntax_error", **site, operation: "parsing code", 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.
@@ -73,7 +73,7 @@ module Fusion
     # --- 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 (| |: |? |+) · * / % // · + - · ?? · == · && · ||
+    #   postfix · unary (! - / ~) · pipe (| |: |? |+) · * / % // · + - · ?? < <= > >= · == · && · ||
     # `@OP.*` is a shadowable `:name` reference, so a local `@OP` reskins the operators.
 
     def parse_or
@@ -103,12 +103,24 @@ module Fusion
       fold_operator(operands, "equal")
     end
 
-    # `??` (compare) is binary and left-associative — it does not fold.
+    # 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
-      while at?(:qq)
-        advance
-        node = pipe_operator([node, parse_additive], "compare")
+      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
@@ -131,7 +143,7 @@ module Fusion
     # 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
+      run = nil # accumulating product-run terms, or nil
       loop do
         if at?(:star) || at?(:slash)
           inverted = at?(:slash)
@@ -165,10 +177,12 @@ module Fusion
         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),
-          ])
+          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
@@ -179,8 +193,7 @@ module Fusion
 
     # 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
+    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 `|`.
@@ -261,12 +274,15 @@ module Fusion
     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}"
@@ -284,6 +300,7 @@ module Fusion
 
       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
 
@@ -309,6 +326,7 @@ module Fusion
           items << ArrayItem.new(value: parse_expr)
         end
         break unless at?(:comma)
+
         advance
       end
       expect(:rbracket)
@@ -329,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)
@@ -358,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)
@@ -384,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
@@ -412,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 minus
-                             lbracket lbrace ident].freeze
+    GUARDEDPAT_STARTERS = [:number, :string, :true_kw, :false_kw, :null_kw, :minus, :lbracket, :lbrace, :ident].freeze
 
     def parse_errpat
       expect(:bang)
@@ -440,9 +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 :minus then advance; Pattern::PLit.new(value: -expect(:number).value)  # negative literal
+      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
@@ -473,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)
@@ -499,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)
@@ -530,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"
+  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

@@ -4,10 +4,10 @@
 # the rest.
 (
   {"f": _ ? @Function, "c": []} => true,
-  {"f": f ? @Function, "c": [x, ...rest]} => (x | f) | (
+  {"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}"]},
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@all", "status": 0, "input": x, "expected": ["{\"f\": _ ? @Function, \"c\": _ ? @Collection}"]},
 )

data/stdlib/any.fsn

@@ -4,9 +4,9 @@
 (
   {"f": _ ? @Function, "c": []} => false,
   {"f": f ? @Function, "c": [x, ...rest]} => x | f | (
-    _ ? @falsey => {"f": f, "c": rest} | @,
-    _           => true,
+    _ ? @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\": _ ? @Array}", "{\"f\": _ ? @Function, \"c\": _ ? @Object}"]},
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@any", "status": 0, "input": x, "expected": ["{\"f\": _ ? @Function, \"c\": _ ? @Collection}"]},
 )

data/stdlib/compact.fsn

@@ -1,6 +1,5 @@
 # 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"]}
+  c ? @Collection => c |? (null => false, _ => true),
+  x => !{"kind": "argument_error", "origin": "stdlib", "operation": "@compact", "status": 0, "input": x, "expected": ["_ ? @Collection"]}
 )

data/stdlib/concat.fsn

@@ -1,5 +1,6 @@
-# Concatenate two strings. Input: [a, b]. Built on @join with an empty separator.
+# Concatenate an array of strings, of any length. 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]"]}
+  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)"]}
 )