fusion-lang 0.0.1 → 0.0.2

data/exe/fusion

@@ -22,9 +22,9 @@ end
 begin
   options = Fusion::CLI::Options.parse(ARGV)
   Fusion::CLI.run(options)
-rescue Fusion::CLI::Options::UsageError => err
+rescue Fusion::CLI::Options::UsageError => e
   # A command-line misuse is plain text on stderr, not a payloaded Fusion error,
   # whether caught while parsing options or early during execution, e.g. by
   # detecting empty stdin plus "-!".
-  abort("fusion: #{err.message}\n\n#{Fusion::CLI::Options::USAGE}")
+  abort("fusion: #{e.message}\n\n#{Fusion::CLI::Options::USAGE}")
 end

data/lib/fusion/ast.rb

@@ -14,7 +14,7 @@ module Fusion
     # A syntactic identifier: a bound/looked-up name, a `.key`, or a `...rest`
     # binder. Mirrors the lexer's ident rule (Lexer#ident_start? / #ident_part?).
     # Object *keys* are arbitrary strings, not identifiers, so they stay `String`.
-    Identifier = /\A[A-Za-z_][A-Za-z0-9_]*\z/
+    IDENTIFIER = /\A[A-Za-z_][A-Za-z0-9_]*\z/
 
     # Expression and Pattern nodes each form a closed family, declared up front
     # (empty) so a member of either may reference the other. Each module is
@@ -28,31 +28,66 @@ module Fusion
     # Auxiliary typed parts: the elements a collection node holds. NOT themselves
     # expressions or patterns, so they live outside the marker families and never
     # satisfy an `Expression`/`Pattern` field.
-    ArrayItem    = TypedData.define(value: Expression)                            # an array element
-    ArraySpread  = TypedData.define(value: Expression)                            # ...expr inside an array
-    KeyValuePair = TypedData.define(key: String, value: Expression)               # "k": expr inside an object
-    ObjectSpread = TypedData.define(value: Expression)                            # ...expr inside an object
-    Clause       = TypedData.define(pattern: Pattern, body: Expression)           # one  pattern => body  of a function
-    PatternItem  = TypedData.define(pattern: Pattern)                             # a sub-pattern of an array pattern
-    PatternPair  = TypedData.define(key: String, pattern: Pattern)                # "k": pat inside an object pattern
-    PatternRest  = TypedData.define(name: ->(v) { Identifier === v || v.nil? })   # ...name (name nil = ignore) in either
+
+    # An array element
+    ArrayItem = TypedData.define(value: Expression)
+
+    # `...expr` inside an array
+    ArraySpread = TypedData.define(value: Expression)
+
+    # `"k": expr` inside an object
+    KeyValuePair = TypedData.define(key: String, value: Expression)
+
+    # `...expr` inside an object
+    ObjectSpread = TypedData.define(value: Expression)
+
+    # One `pattern => body` of a function
+    Clause = TypedData.define(pattern: Pattern, body: Expression)
+
+    # A sub-pattern of an array pattern
+    PatternItem = TypedData.define(pattern: Pattern)
+
+    # `"k": pat` inside an object pattern
+    PatternPair = TypedData.define(key: String, pattern: Pattern)
+
+    # `...name` in array/object pattern. (name nil = don't bind)
+    PatternRest = TypedData.define(name: ->(v) { IDENTIFIER === v || v.nil? })
 
     module Expression
-      Lit       = TypedData.define(value: Atom)                                                      # atom literal (incl NULL)
-      ErrLit    = TypedData.define(payload: ->(v) { Expression === v || v.nil? })                    # !expr or bare ! (payload nil = !null)
-      ArrLit    = TypedData.define(items: ->(v) { v.is_a?(Array) && v.all? { |e| ArrayItem === e || ArraySpread === e } })
-      ObjLit    = TypedData.define(pairs: ->(v) {                                                    # [KeyValuePair|ObjectSpread], distinct fixed keys
+      # Atom literal (incl NULL)
+      Lit = TypedData.define(value: Atom)
+
+      # `!expr` or bare `!` (payload nil = !null)
+      ErrLit = TypedData.define(payload: ->(v) { Expression === v || v.nil? })
+
+      ArrLit = TypedData.define(items: ->(v) { v.is_a?(Array) && v.all? { |e| ArrayItem === e || ArraySpread === e } })
+
+      # [KeyValuePair|ObjectSpread], distinct fixed keys
+      ObjLit = TypedData.define(pairs: ->(v) {
         v.is_a?(Array) &&
           v.all? { |m| KeyValuePair === m || ObjectSpread === m } &&
           v.filter_map { |m| m.key if KeyValuePair === m }.then { |keys| keys.uniq.size == keys.size }
       })
-      FuncLit   = TypedData.define(clauses: ->(v) { v.is_a?(Array) && v.all? { |c| Clause === c } }) # [] = the empty function
-      Ident     = TypedData.define(name: Identifier)                                                 # read a builtin/bound name
-      FileRef   = TypedData.define(variety: ->(v) { %i[self super super_name name path].include?(v) }, path: ->(v) { String === v || v.nil? })
-      Pipe      = TypedData.define(left: Expression, right: Expression)                              # left | right
-      Member    = TypedData.define(obj: Expression, key: Identifier)                                 # obj.key
-      Index     = TypedData.define(obj: Expression, idx: Expression)                                 # obj[expr]
-      IndexSet  = TypedData.define(obj: Expression, idx: Expression, value: Expression)              # obj[expr = expr]
+
+      # [] = the empty function
+      FuncLit = TypedData.define(clauses: ->(v) { v.is_a?(Array) && v.all? { |c| Clause === c } })
+
+      # Read a builtin/bound name
+      Ident = TypedData.define(name: IDENTIFIER)
+
+      FileRef = TypedData.define(variety: ->(v) { [:self, :super, :super_name, :name, :path].include?(v) }, path: ->(v) { String === v || v.nil? })
+
+      # `left | right`
+      Pipe = TypedData.define(left: Expression, right: Expression)
+
+      # `obj.key`
+      Member = TypedData.define(obj: Expression, key: IDENTIFIER)
+
+      # `obj[expr]`
+      Index = TypedData.define(obj: Expression, idx: Expression)
+
+      # `obj[expr = expr]`
+      IndexSet = TypedData.define(obj: Expression, idx: Expression, value: Expression)
 
       constants.each do |name|
         node = const_get(name)
@@ -61,22 +96,35 @@ module Fusion
     end
 
     module Pattern
-      PLit      = TypedData.define(value: Atom)                                                     # literal pattern
-      PErr      = TypedData.define(inner: Pattern)                                                  # ! or !pat ; inner=PWild matches any error
-      PBind     = TypedData.define(name: Identifier)                                                # binds
-      PWild     = TypedData.define(dummy: NilClass)                                                 # _
-      PArr      = TypedData.define(items: ->(v) {                                                   # [PatternItem|PatternRest], at most one rest
+      # literal pattern
+      PLit = TypedData.define(value: Atom)
+
+      # `!` or `!pat` ; inner=PWild matches any error
+      PErr = TypedData.define(inner: Pattern)
+
+      # binds
+      PBind = TypedData.define(name: IDENTIFIER)
+
+      # `_`
+      PWild = TypedData.define(dummy: NilClass)
+
+      # [PatternItem|PatternRest], at most one rest
+      PArr = TypedData.define(items: ->(v) {
         v.is_a?(Array) &&
           v.all? { |e| PatternItem === e || PatternRest === e } &&
           v.count { |e| PatternRest === e } <= 1
       })
-      PObj      = TypedData.define(pairs: ->(v) {                                                   # [PatternPair|PatternRest], one rest, distinct keys
+
+      # [PatternPair|PatternRest], one rest, distinct keys
+      PObj = TypedData.define(pairs: ->(v) {
         v.is_a?(Array) &&
           v.all? { |m| PatternPair === m || PatternRest === m } &&
           v.count { |m| PatternRest === m } <= 1 &&
           v.filter_map { |m| m.key if PatternPair === m }.then { |keys| keys.uniq.size == keys.size }
       })
-      PGuard    = TypedData.define(inner: Pattern, pred_expr: Expression)                           # inner ? predicate
+
+      # `inner ? predicate`
+      PGuard = TypedData.define(inner: Pattern, pred_expr: Expression)
 
       constants.each do |name|
         node = const_get(name)
@@ -86,7 +134,7 @@ module Fusion
 
     module Statement
       # The only statement. Only allowed in the REPL. `name = expression`.
-      Assignment = TypedData.define(name: Identifier, expression: Expression)
+      Assignment = TypedData.define(name: IDENTIFIER, expression: Expression)
 
       constants.each do |name|
         node = const_get(name)

data/lib/fusion/atom.rb

@@ -11,7 +11,7 @@ module Fusion
   # A scalar literal value: the JSON atoms plus NULL (everything the lexer
   # emits as a token value, see Lexer#lex_number and #lex_word).
   Atom = ->(v) {
-    v == NULL ||  v == true || v == false ||
+    v == NULL || v == true || v == false ||
       v.is_a?(Integer) || v.is_a?(Float) || v.is_a?(String)
   }
 end

data/lib/fusion/cli/decoder.rb

@@ -26,7 +26,7 @@ module Fusion
             next unless raw.is_a?(Array) && raw.length == 2 && raw[0].is_a?(Integer)
 
             # The tag must be exactly the integer 0 or 1 (no 0.0 — Fusion equality is exact).
-            [raw[0], raw[1]] if raw[0] == 0 || raw[0] == 1
+            [raw[0], raw[1]] if [0, 1].include?(raw[0])
           end
         when :object
           decode_envelope(text, mode) do |raw|
@@ -68,12 +68,12 @@ module Fusion
         return WirePair.new(status: status, data: JSON.generate(inner)) if status
 
         WirePair.new(status: 1, data: JSON.generate(
-          "kind" => "argument_error",
-          "origin" => "input",
+          "kind"      => "argument_error",
+          "origin"    => "input",
           "operation" => "decoding input",
-          "status" => 0,
-          "input" => raw,
-          "expected" => EXPECTED_ENVELOPE_SHAPES.fetch(mode)
+          "status"    => 0,
+          "input"     => raw,
+          "expected"  => EXPECTED_ENVELOPE_SHAPES.fetch(mode),
         ))
       rescue JSON::ParserError
         # TODO: BUG ???

data/lib/fusion/cli/encoder.rb

@@ -12,12 +12,12 @@ module Fusion
       def encode(wire_pair, mode:)
         case mode
         when :bang
-          bang = wire_pair.status.zero? ? "" : "!"
+          bang = wire_pair.status == 0 ? "" : "!"
           "#{bang}#{wire_pair.data}"
         when :array
           "[#{wire_pair.status},#{wire_pair.data}]"
         when :object
-          key = wire_pair.status.zero? ? "value" : "error"
+          key = wire_pair.status == 0 ? "value" : "error"
           "{\"#{key}\":#{wire_pair.data}}"
         else
           raise Unreachable, "Unknown output mode #{mode}"

data/lib/fusion/cli/options.rb

@@ -52,7 +52,7 @@ module Fusion
           object  {"value": _} marks a value, {"error": _} an error
       TEXT
 
-      MODES = %w[unix bang array object].freeze
+      MODES = ['unix', 'bang', 'array', 'object'].freeze
 
       attr_reader :use_case, :input_mode, :output_mode, :inline_source, :program_path, :jail
 
@@ -138,12 +138,12 @@ module Fusion
       # exe/fusion reports them as plain usage text (never a payloaded error).
       def self.run_parser(parser, argv)
         parser.parse(argv)
-      rescue OptionParser::InvalidOption => error
-        raise UsageError, "unknown option #{error.args.join(' ')}"
-      rescue OptionParser::MissingArgument => error
-        raise UsageError, missing_argument_message(error.args.first)
-      rescue OptionParser::ParseError => error
-        raise UsageError, error.message
+      rescue OptionParser::InvalidOption => e
+        raise UsageError, "unknown option #{e.args.join(' ')}"
+      rescue OptionParser::MissingArgument => e
+        raise UsageError, missing_argument_message(e.args.first)
+      rescue OptionParser::ParseError => e
+        raise UsageError, e.message
       end
 
       # A MODE value -> its symbol, or a UsageError naming the valid modes.
@@ -174,12 +174,14 @@ module Fusion
           unless input_mode.nil? && output_mode.nil? && !error_input && inline_source.nil? && positional.empty?
             raise UsageError, "--repl takes no program, no input, and no modes"
           end
+
           program_path = nil
         when :stream
           input_mode ||= :array
           output_mode ||= :array
           raise UsageError, "--stream does not support the unix mode" if input_mode == :unix || output_mode == :unix
           raise UsageError, "-! requires the unix input mode" if error_input
+
           program_path = inline_source ? nil : positional.shift
           raise UsageError, "missing program (a .fsn file or -e)" unless inline_source || program_path
           raise UsageError, "too many positional arguments" unless positional.empty?
@@ -187,6 +189,7 @@ module Fusion
           input_mode ||= :unix
           output_mode ||= :unix
           raise UsageError, "-! requires the unix input mode" if error_input && input_mode != :unix
+
           program_path = inline_source ? nil : positional.shift
           raise UsageError, "missing program (a .fsn file or -e)" unless inline_source || program_path
           raise UsageError, "too many positional arguments" unless positional.empty?
@@ -202,7 +205,7 @@ module Fusion
           program_path: program_path,
           error_input: error_input,
           skip_blank_lines: skip_blank_lines,
-          jail: jail
+          jail: jail,
         )
       end
 

data/lib/fusion/cli/parser.rb

@@ -19,7 +19,7 @@ module Fusion
           origin: "input",
           operation: "parsing JSON",
           input: wire_pair.data,
-          message: "input is not valid JSON"
+          message: "input is not valid JSON",
         )
       end
 

data/lib/fusion/cli/repl.rb

@@ -14,10 +14,10 @@ module Fusion
       GREEN      = "\e[32m"
       RED        = "\e[31m"
 
-      PROMPT              = "#{LIGHT_BLUE}fsn> #{RESET}"
-      CONTINUATION_PROMPT = "#{LIGHT_BLUE}...> #{RESET}"
-      VALUE_MARKER        = "#{GREEN}✔ #{RESET}"
-      ERROR_MARKER        = "#{RED}✗ #{RESET}"
+      PROMPT              = "#{LIGHT_BLUE}fsn> #{RESET}".freeze
+      CONTINUATION_PROMPT = "#{LIGHT_BLUE}...> #{RESET}".freeze
+      VALUE_MARKER        = "#{GREEN}✔ #{RESET}".freeze
+      ERROR_MARKER        = "#{RED}✗ #{RESET}".freeze
 
       # REPL entries report errors with the same site as inline (`-e`) code.
       SITE = { origin: "code", file: "<inline>" }.freeze
@@ -32,7 +32,7 @@ module Fusion
         require "reline"
         Reline.output = $stderr
         Reline.prompt_proc = proc do |lines|
-          lines.each_index.map { |i| i.zero? ? PROMPT : CONTINUATION_PROMPT }
+          lines.each_index.map { |i| i == 0 ? PROMPT : CONTINUATION_PROMPT }
         end
 
         # The session env is a child of the run's root, so it carries the jail;
@@ -43,7 +43,7 @@ module Fusion
           buffer = begin
             Reline.readmultiline(PROMPT, true) { complete?(_1) }
           rescue Interrupt
-            $stderr.puts("^C") # discard the half-typed entry and re-prompt
+            warn("^C") # discard the half-typed entry and re-prompt
             next
           end
 

data/lib/fusion/cli/serializer.rb

@@ -13,7 +13,7 @@ module Fusion
       # Only use "lenient: true" in the REPL!
       def serialize(runtime_value, lenient: false)
         message = catch(:unserializable) do
-          if runtime_value.is_a?(Interpreter::ErrorVal)
+          if runtime_value.is_a?(Interpreter::ErrorVal) # rubocop:disable Style/GuardClause
             error = runtime_value
             data = convert(error.payload, lenient: lenient || error.runtime?).to_json
             return WirePair.new(status: 1, data: data)
@@ -27,7 +27,7 @@ module Fusion
           origin: "output",
           operation: "serializing result",
           input: runtime_value,
-          message: message
+          message: message,
         )
 
         serialize(runtime_error, lenient: true)
@@ -42,6 +42,7 @@ module Fusion
           nil
         when Float
           return runtime_value if runtime_value.finite?
+
           throw(:unserializable, "cannot serialize a non-finite number") unless lenient
 
           "<#{runtime_value}>" # "<Infinity>" / "<-Infinity>" / "<NaN>"
@@ -56,11 +57,9 @@ module Fusion
         when true, false, String, Numeric
           runtime_value
         when Interpreter::ErrorVal
-          if lenient
-            "!#{convert(runtime_value.payload, lenient:).to_json}"
-          else
-            raise Unreachable, "ErrorVal should have been handled at the top level of convert"
-          end
+          raise Unreachable, "ErrorVal should have been handled at the top level of convert" unless lenient
+
+          "!#{convert(runtime_value.payload, lenient:).to_json}"
         else
           raise Unreachable, "Unhandled type in convert: #{runtime_value.class}"
         end

data/lib/fusion/cli.rb

@@ -173,7 +173,7 @@ module Fusion
     # WirePair -> stdout/stderr
     def emit_output(wire_pair, output_mode:)
       if output_mode == :unix
-        channel = wire_pair.status.zero? ? $stdout : $stderr
+        channel = wire_pair.status == 0 ? $stdout : $stderr
         channel.puts(wire_pair.data)
         exit(wire_pair.status)
       else

data/lib/fusion/interpreter/builtins.rb

@@ -12,9 +12,7 @@ module Fusion
         define = ->(name, fn) { table[name] = NativeFunc.new(name, fn) }
 
         # Irreducible primitives kept as built-ins. The sugar-target operators
-        # (arithmetic/comparison/boolean) live in `@OP` below; their friendly
-        # derived forms (`@lt`, `@gt`, `@truthy`, …) are stdlib files that build on
-        # `@OP.*`, so they follow a per-directory `@OP` override. Numeric functions
+        # (arithmetic/comparison/boolean) live in `@OP` below. Numeric functions
         # (`round`, `divide`, `sin`, …) and constants (`pi`, `e`) live in `@math`.
         define.call("size", method(:size))
         define.call("join", method(:join))
@@ -23,7 +21,6 @@ module Fusion
         define.call("parseNumber", method(:parse_number))
         define.call("keys", method(:keys))
         define.call("values", method(:values))
-        define.call("toObject", method(:to_object))
 
         # type predicates: return false on any non-matching value, never an error
         define.call("Integer", method(:integer?))
@@ -33,6 +30,7 @@ module Fusion
         define.call("Boolean", method(:boolean?))
         define.call("Array", method(:array?))
         define.call("Object", method(:object?))
+        define.call("Collection", method(:collection?))
         define.call("Null", method(:null?))
         define.call("Function", method(:function?))
         define.call("NonFinite", method(:non_finite?))
@@ -51,6 +49,10 @@ module Fusion
           "modulo"   => NativeFunc.new("OP.modulo", method(:op_modulo)),
           "equal"    => NativeFunc.new("OP.equal", method(:op_equal)),
           "compare"  => NativeFunc.new("OP.compare", method(:op_compare)),
+          "lt"       => NativeFunc.new("OP.lt", method(:op_lt)),
+          "gt"       => NativeFunc.new("OP.gt", method(:op_gt)),
+          "lte"      => NativeFunc.new("OP.lte", method(:op_lte)),
+          "gte"      => NativeFunc.new("OP.gte", method(:op_gte)),
           "and"      => NativeFunc.new("OP.and", method(:op_and)),
           "or"       => NativeFunc.new("OP.or", method(:op_or)),
           "not"      => NativeFunc.new("OP.not", method(:op_not)),
@@ -143,7 +145,7 @@ module Fusion
       def math_rand(v)
         return v if v.is_a?(ErrorVal)
         return rand if v == NULL
-        return rand(v) if integer?(v) && v.positive?
+        return rand(v) if integer?(v) && v > 0
 
         argument_error("math.rand", v, ["_ ? @Null", '_ ? (n ? @Integer => [0, n] | @OP.compare | (-1 => true))'])
       end
@@ -197,7 +199,7 @@ module Fusion
         return argument_error("math.pow", v, NUMBER_PAIR) unless pair?(v) && numeric?(v[0]) && numeric?(v[1])
 
         a, b = v
-        result = a.is_a?(Integer) && b.is_a?(Integer) && !b.negative? ? a**b : a.to_f**b
+        result = a.is_a?(Integer) && b.is_a?(Integer) && b >= 0 ? a**b : a.to_f**b
         return error("math_error", "math.pow", v, "not in domain (complex result)") if result.is_a?(Complex)
 
         result
@@ -206,9 +208,8 @@ module Fusion
       # --- OP: the sugar-target operators (reached as `@OP.sum`, `@OP.and`, …) ---
       #
       # The arithmetic, boolean, and equality members take an array of ANY length;
-      # the unary ones take a single value; `compare` returns -1 / 0 / 1. The
-      # friendly derived forms (`@lt`, `@gt`, `@truthy`, …) are stdlib files built on
-      # these.
+      # the unary ones take a single value; `compare` returns -1 / 0 / 1, which
+      # `lt` / `gt` / `lte` / `gte` then read into a boolean.
 
       def op_sum(v)
         return v if v.is_a?(ErrorVal)
@@ -289,6 +290,26 @@ module Fusion
         end
       end
 
+      # The comparison readers interpret an `@OP.compare` result. The infix sugar
+      # `a < b` desugars to `[a, b] | @OP.compare | @OP.lt` (likewise `<=` / `>` /
+      # `>=`), so an `@OP` override reskins the ordering and its reading together.
+
+      def op_lt(v)
+        read_compare_result("OP.lt", v, [-1])
+      end
+
+      def op_gt(v)
+        read_compare_result("OP.gt", v, [1])
+      end
+
+      def op_lte(v)
+        read_compare_result("OP.lte", v, [-1, 0])
+      end
+
+      def op_gte(v)
+        read_compare_result("OP.gte", v, [0, 1])
+      end
+
       def op_and(v)
         return v if v.is_a?(ErrorVal)
         return argument_error("OP.and", v, ["_ ? @Array"]) unless v.is_a?(Array)
@@ -313,7 +334,7 @@ module Fusion
 
       def size(v)
         return v if v.is_a?(ErrorVal)
-        return argument_error("size", v, ["_ ? @String", "_ ? @Array", "_ ? @Object"]) unless v.is_a?(String) || v.is_a?(Array) || v.is_a?(Hash)
+        return argument_error("size", v, ["_ ? @String", "_ ? @Collection"]) unless v.is_a?(String) || v.is_a?(Array) || v.is_a?(Hash)
 
         v.length
       end
@@ -322,6 +343,7 @@ module Fusion
       # is the stdlib pair-case built on this.
       def join(v)
         return v if v.is_a?(ErrorVal)
+
         expected = ['[_ ? (xs => {"c": xs, "f": @String} | @all), _ ? @String]']
         return argument_error("join", v, expected) unless pair?(v)
 
@@ -339,6 +361,7 @@ module Fusion
       # stdlib single-string case built on this.
       def split(v)
         return v if v.is_a?(ErrorVal)
+
         expected = ["[_ ? @String, _ ? @String]"]
         return argument_error("split", v, expected) unless pair?(v) && v[0].is_a?(String) && v[1].is_a?(String)
 
@@ -388,17 +411,6 @@ module Fusion
         v.values
       end
 
-      def to_object(v)
-        return v if v.is_a?(ErrorVal)
-        # Each entry must be a [string, _] pair.
-        expected = ['_ ? (xs => {"c": xs, "f": ([_ ? @String, _] => true)} | @all)']
-        unless v.is_a?(Array) && v.all? { |entry| pair?(entry) && entry[0].is_a?(String) }
-          return argument_error("toObject", v, expected)
-        end
-
-        v.to_h
-      end
-
       private
 
       # Type predicates, also reused as internal guards.
@@ -420,7 +432,7 @@ module Fusion
       end
 
       def boolean?(v)
-        v == true || v == false
+        [true, false].include?(v)
       end
 
       def array?(v)
@@ -431,6 +443,10 @@ module Fusion
         v.is_a?(Hash)
       end
 
+      def collection?(v)
+        array?(v) || object?(v)
+      end
+
       def null?(v)
         v == NULL
       end
@@ -447,6 +463,19 @@ module Fusion
         v.is_a?(Float) && !v.finite?
       end
 
+      COMPARE_RESULT = ["-1", "0", "1", "null"].freeze
+
+      # -1 / 0 / 1 (exact integers) → whether the ordering is in `truthy_results`.
+      # A partial order's compare may return null (incomparable); that passes
+      # through as null rather than being forced to a boolean.
+      def read_compare_result(name, v, truthy_results)
+        return v if v.is_a?(ErrorVal)
+        return NULL if v == NULL
+        return argument_error(name, v, COMPARE_RESULT) unless integer?(v) && [-1, 0, 1].include?(v)
+
+        truthy_results.include?(v)
+      end
+
       # Build a standardized interpreter error carrying a human-readable
       # `message` (see docs/user/reference.md §6.5). Use this for failures that
       # aren't an input-shape mismatch (math, conversion, access). `operation`

data/lib/fusion/interpreter/thunk.rb

@@ -33,9 +33,9 @@ module Fusion
           @state = :forcing
           begin
             @value = @compute.call
-          rescue ReadFailure => failure
+          rescue ReadFailure => e
             # Memoize the Ruby error itself. Turn it into a Fusion runtime error below.
-            @value = failure
+            @value = e
           end
           @state = :done
           @value