fusion-lang 0.0.1.alpha1 → 0.0.1.alpha2

data/lib/fusion/cli.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+# === CLI tools ===
+#
+# Core data types:
+# - WirePair
+# - Fusion runtime value
+
+require_relative "wire_pair"
+require_relative "cli/options"
+
+require_relative "cli/decoder"
+require_relative "cli/parser"
+require_relative "interpreter"
+require_relative "cli/serializer"
+require_relative "cli/encoder"
+
+require_relative "cli/repl"
+
+module Fusion
+  module CLI
+    extend self
+
+    # Run the use case selected on the command line.
+    def run(options)
+      case options.use_case
+      when :pipe then run_pipe(options)
+      when :stream then run_stream(options)
+      when :repl then Repl.new.run
+      else raise Unreachable, "Unknown use case #{options.use_case}"
+      end
+    end
+
+    # pipe: load the program, pipe one input through it, emit one output.
+    def run_pipe(options)
+      function = load_program(options)
+      input    = parse(load_input(options))
+      output   = apply(input, function)
+      emit_output(serialize(output), output_mode: options.output_mode)
+    end
+
+    # stream: load the program once, then treat stdin/stdout as NDJSON streams —
+    # one input per line, one output line per input. Errors stay in-band (the
+    # unix mode is unavailable here), so the exit code is always 0.
+    def run_stream(options)
+      function = load_program(options)
+      $stdout.sync = true
+      $stdin.each_line do |line|
+        next if line.strip.empty?
+
+        input  = parse(decode(line, mode: options.input_mode))
+        output = apply(input, function)
+        $stdout.puts(encode(serialize(output), mode: options.output_mode))
+      end
+    end
+
+    # String -> WirePair
+    # Doesn't support mode `:unix`
+    def decode(string, mode:)
+      Decoder.decode(string, mode:)
+    end
+
+    # WirePair -> runtime value
+    def parse(wire_pair)
+      Parser.parse(wire_pair)
+    end
+
+    # input | function -> output
+    def apply(input, function)
+      Interpreter.safe_apply(function, input)
+    end
+
+    # expression -> runtime value
+    # Mutates environment (REPL variable binding)
+    def evaluate(expression, environment)
+      Interpreter.safe_evaluate(expression, environment)
+    end
+
+    # runtime value -> WirePair
+    def serialize(runtime_value)
+      Serializer.serialize(runtime_value)
+    end
+
+    # WirePair -> String
+    # Doesn't support mode `:unix`
+    def encode(wire_pair, mode:)
+      Encoder.encode(wire_pair, mode:)
+    end
+
+    private
+
+    # input -> WirePair
+    def load_input(options)
+      text = options.explicit_input || ($stdin.tty? ? "" : $stdin.read)
+      empty = text.strip.empty?
+
+      if options.input_mode == :unix || empty
+        WirePair.new(
+          status: options.error_input? ? 1 : 0,
+          data: empty ? "null" : text
+        )
+      else
+        decode(text, mode: options.input_mode)
+      end
+    end
+
+    # WirePair -> output
+    def emit_output(wire_pair, output_mode:)
+      if output_mode == :unix
+        channel = wire_pair.status.zero? ? $stdout : $stderr
+        channel.puts(wire_pair.data)
+        exit(wire_pair.status)
+      else
+        $stdout.puts(encode(wire_pair, mode: output_mode))
+        exit 0
+      end
+    end
+
+    # Load the program (a `.fsn` file or an inline `-e` source) into the runtime
+    # value it evaluates to — usually a function. A parse error or a non-function
+    # value flows on as the program value and surfaces when `apply` runs it.
+    def load_program(options)
+      interpreter = Fusion::Interpreter.new
+      if options.inline_source
+        ast = Fusion::Parser.parse_file(options.inline_source, location: "code <inline>")
+        return ast if ast.is_a?(Fusion::Interpreter::ErrorVal) # a parse error
+
+        env = interpreter.root_env.child
+        env.define("__dir__", Dir.pwd)
+        interpreter.eval_expr(ast, env)
+      else
+        interpreter.load_file(File.expand_path(options.program_path)).force
+      end
+    end
+  end
+end

data/lib/fusion/interpreter/builtins.rb

@@ -0,0 +1,356 @@
+# frozen_string_literal: true
+
+# === Interpreter internals ===
+
+module Fusion
+  class Interpreter
+    module Builtins
+      extend self
+
+      def install(table, interp)
+        @interp = interp
+        define = ->(name, fn) { table[name] = NativeFunc.new(name, fn) }
+
+        # operations on a pair [a, b] (or a single value)
+        define.call("add", method(:add))
+        define.call("subtract", method(:subtract))
+        define.call("multiply", method(:multiply))
+        define.call("divide", method(:divide))
+        define.call("mod", method(:mod))
+        define.call("negate", method(:negate))
+        define.call("floor", method(:floor))
+        define.call("equals", method(:equals))
+        define.call("lessThan", method(:less_than))
+        define.call("and", method(:and_))
+        define.call("or", method(:or_))
+        define.call("not", method(:not_))
+        define.call("length", method(:length))
+        define.call("concat", method(:concat))
+        define.call("chars", method(:chars))
+        define.call("join", method(:join))
+        define.call("toString", method(:to_string))
+        define.call("parseNumber", method(:parse_number))
+        define.call("keys", method(:keys))
+        define.call("values", method(:values))
+        define.call("get", method(:get))
+        define.call("set", method(:set))
+        define.call("toObject", method(:to_object))
+
+        # type predicates: return false on any non-matching value, never an error
+        define.call("Integer", method(:integer?))
+        define.call("Float", method(:float?))
+        define.call("Number", method(:numeric?))
+        define.call("String", method(:string?))
+        define.call("Boolean", method(:boolean?))
+        define.call("Array", method(:array?))
+        define.call("Object", method(:object?))
+        define.call("Null", method(:null?))
+        define.call("Function", method(:function?))
+        define.call("NonFinite", method(:non_finite?))
+      end
+
+      # --- arithmetic ---
+
+      def add(v)
+        return v if v.is_a?(ErrorVal)
+        return error("argument_error", "add", v, "expected [_, _]") unless pair?(v)
+        return error("type_error", "add", v, "expected numbers") unless numeric?(v[0])
+        return error("type_error", "add", v, "expected numbers") unless numeric?(v[1])
+
+        v[0] + v[1]
+      end
+
+      def subtract(v)
+        return v if v.is_a?(ErrorVal)
+        return error("argument_error", "subtract", v, "expected [_, _]") unless pair?(v)
+        return error("type_error", "subtract", v, "expected numbers") unless numeric?(v[0])
+        return error("type_error", "subtract", v, "expected numbers") unless numeric?(v[1])
+
+        v[0] - v[1]
+      end
+
+      def multiply(v)
+        return v if v.is_a?(ErrorVal)
+        return error("argument_error", "multiply", v, "expected [_, _]") unless pair?(v)
+        return error("type_error", "multiply", v, "expected numbers") unless numeric?(v[0])
+        return error("type_error", "multiply", v, "expected numbers") unless numeric?(v[1])
+
+        v[0] * v[1]
+      end
+
+      def divide(v)
+        return v if v.is_a?(ErrorVal)
+        return error("argument_error", "divide", v, "expected [_, _]") unless pair?(v)
+        return error("type_error", "divide", v, "expected numbers") unless numeric?(v[0])
+        return error("type_error", "divide", v, "expected numbers") unless numeric?(v[1])
+        return error("math_error", "divide", v, "division by zero") if v[1] == 0
+
+        a, b = v
+        if a.is_a?(Integer) && b.is_a?(Integer) && (a % b).zero?
+          a / b
+        else
+          a.to_f / b
+        end
+      end
+
+      def mod(v)
+        return v if v.is_a?(ErrorVal)
+        return error("argument_error", "mod", v, "expected [_, _]") unless pair?(v)
+        return error("type_error", "mod", v, "expected numbers") unless numeric?(v[0])
+        return error("type_error", "mod", v, "expected numbers") unless numeric?(v[1])
+        return error("math_error", "mod", v, "modulo by zero") if v[1] == 0
+
+        v[0] % v[1]
+      end
+
+      def negate(v)
+        return v if v.is_a?(ErrorVal)
+        return error("type_error", "negate", v, "expected a number") unless numeric?(v)
+
+        -v
+      end
+
+      def floor(v)
+        return v if v.is_a?(ErrorVal)
+        return error("type_error", "floor", v, "expected a number") unless numeric?(v)
+        return error("math_error", "floor", v, "not a finite number") if non_finite?(v)
+
+        v.floor
+      end
+
+      # --- comparison ---
+
+      def equals(v)
+        return v if v.is_a?(ErrorVal)
+        return error("argument_error", "equals", v, "expected [_, _]") unless pair?(v)
+
+        @interp.deep_equal?(v[0], v[1])
+      end
+
+      def less_than(v)
+        return v if v.is_a?(ErrorVal)
+        return error("argument_error", "lessThan", v, "expected [_, _]") unless pair?(v)
+
+        a, b = v
+        if numeric?(a) && numeric?(b)
+          a < b
+        elsif a.is_a?(String) && b.is_a?(String)
+          a < b
+        else
+          error("type_error", "lessThan", v, "expected two numbers or two strings")
+        end
+      end
+
+      # --- boolean ---
+
+      # `and`/`or`/`not` judge truthiness (Ruby-style: `false` and `null` are
+      # falsey, everything else truthy), not strict booleans, and always return a
+      # boolean. They share the interpreter's `truthy?`, the same test `?` guards use.
+      def and_(v)
+        return v if v.is_a?(ErrorVal)
+        return error("argument_error", "and", v, "expected [_, _]") unless pair?(v)
+
+        @interp.truthy?(v[0]) && @interp.truthy?(v[1])
+      end
+
+      def or_(v)
+        return v if v.is_a?(ErrorVal)
+        return error("argument_error", "or", v, "expected [_, _]") unless pair?(v)
+
+        @interp.truthy?(v[0]) || @interp.truthy?(v[1])
+      end
+
+      def not_(v)
+        return v if v.is_a?(ErrorVal)
+
+        !@interp.truthy?(v)
+      end
+
+      # --- strings and structure bridges ---
+
+      def length(v)
+        return v if v.is_a?(ErrorVal)
+        return error("type_error", "length", v, "expected a string, array, or object") unless v.is_a?(String) || v.is_a?(Array) || v.is_a?(Hash)
+
+        v.length
+      end
+
+      def concat(v)
+        return v if v.is_a?(ErrorVal)
+        return error("argument_error", "concat", v, "expected [_, _]") unless pair?(v)
+        return error("type_error", "concat", v, "expected strings") unless v[0].is_a?(String) && v[1].is_a?(String)
+
+        v[0] + v[1]
+      end
+
+      def chars(v)
+        return v if v.is_a?(ErrorVal)
+        return error("type_error", "chars", v, "expected a string") unless v.is_a?(String)
+
+        v.chars
+      end
+
+      def join(v)
+        return v if v.is_a?(ErrorVal)
+        return error("argument_error", "join", v, "expected [_, _]") unless pair?(v)
+
+        array, separator = v
+        unless array.is_a?(Array) && separator.is_a?(String) && array.all? { |item| item.is_a?(String) }
+          return error("type_error", "join", v, "expected [array-of-strings, separator-string]")
+        end
+
+        array.join(separator)
+      end
+
+      def to_string(v)
+        return v if v.is_a?(ErrorVal)
+
+        case v
+        when String then v
+        when Integer, Float then v.to_s
+        when true then "true"
+        when false then "false"
+        when NULL then "null"
+        else error("conversion_error", "toString", v, "cannot stringify this value type")
+        end
+      end
+
+      def parse_number(v)
+        return v if v.is_a?(ErrorVal)
+        return error("type_error", "parseNumber", v, "expected a string") unless v.is_a?(String)
+
+        case v
+        when /\A-?\d+\z/ then v.to_i
+        when /\A-?\d+(\.\d+)?([eE][+-]?\d+)?\z/ then v.to_f
+        else error("conversion_error", "parseNumber", v, "not a numeric string")
+        end
+      end
+
+      # --- object key enumeration (Tier 0: patterns can't enumerate unknown keys) ---
+
+      def keys(v)
+        return v if v.is_a?(ErrorVal)
+        return error("type_error", "keys", v, "expected an object") unless v.is_a?(Hash)
+
+        v.keys
+      end
+
+      def values(v)
+        return v if v.is_a?(ErrorVal)
+        return error("type_error", "values", v, "expected an object") unless v.is_a?(Hash)
+
+        v.values
+      end
+
+      # Read from an array (integer index, negative counts from the end) or an
+      # object (string key) — mirroring the `[]` operator (reference §8).
+      def get(v)
+        return v if v.is_a?(ErrorVal)
+        return error("argument_error", "get", v, "expected [_, _]") unless pair?(v)
+
+        container, key = v
+        if container.is_a?(Array) && key.is_a?(Integer)
+          i = key.negative? ? container.length + key : key
+          return container[i] if i >= 0 && i < container.length
+
+          error("access_error", "get", v, "index out of range")
+        elsif container.is_a?(Hash) && key.is_a?(String)
+          return container[key] if container.key?(key)
+
+          error("access_error", "get", v, "missing key")
+        else
+          error("type_error", "get", v, "bad index type")
+        end
+      end
+
+      # Return a new array/object with one entry set. An array index must already
+      # exist (arrays are not extended); an object key may be new. Addressing
+      # mirrors `@get` (array by integer index, object by string key).
+      def set(v)
+        return v if v.is_a?(ErrorVal)
+        return error("argument_error", "set", v, "expected [_, _, _]") unless v.is_a?(Array) && v.length == 3
+
+        container, key, value = v
+        if container.is_a?(Array) && key.is_a?(Integer)
+          i = key.negative? ? container.length + key : key
+          return error("access_error", "set", v, "index out of range") unless i >= 0 && i < container.length
+
+          container.dup.tap { |copy| copy[i] = value }
+        elsif container.is_a?(Hash) && key.is_a?(String)
+          container.merge(key => value)
+        else
+          error("type_error", "set", v, "bad index type")
+        end
+      end
+
+      def to_object(v)
+        return v if v.is_a?(ErrorVal)
+        return error("type_error", "toObject", v, "expected an array") unless v.is_a?(Array)
+        unless v.all? { |entry| pair?(entry) && entry[0].is_a?(String) }
+          return error("type_error", "toObject", v, "expected [string, value] entries")
+        end
+
+        v.to_h
+      end
+
+      private
+
+      # Type predicates, also reused as internal guards.
+
+      def integer?(v)
+        v.is_a?(Integer) && !boolean?(v)
+      end
+
+      def float?(v)
+        v.is_a?(Float)
+      end
+
+      def numeric?(v)
+        v.is_a?(Numeric) && !boolean?(v)
+      end
+
+      def string?(v)
+        v.is_a?(String)
+      end
+
+      def boolean?(v)
+        v == true || v == false
+      end
+
+      def array?(v)
+        v.is_a?(Array)
+      end
+
+      def object?(v)
+        v.is_a?(Hash)
+      end
+
+      def null?(v)
+        v == NULL
+      end
+
+      def function?(v)
+        v.is_a?(Func) || v.is_a?(NativeFunc)
+      end
+
+      def pair?(v)
+        v.is_a?(Array) && v.length == 2
+      end
+
+      def non_finite?(v)
+        v.is_a?(Float) && !v.finite?
+      end
+
+      # Build a standardized interpreter error (see docs/user/reference.md §6.5).
+      def error(kind, name, v, message)
+        ErrorVal.internal(
+          kind: kind,
+          location: "builtin #{name}",
+          operation: name,
+          input: v,
+          message: message
+        )
+      end
+    end
+  end
+end

data/lib/fusion/interpreter/env.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+# === Interpreter internals ===
+#
+# Environment: maps names -> values, with a parent chain. Built-ins live at root.
+
+module Fusion
+  class Interpreter
+    class Env
+      # Raised by #bind when a name is already bound in this env's own scope —
+      # i.e. a duplicate pattern binder like `[a, a]`. Interpreter#apply catches
+      # it and reports a binding_error (see docs/user/reference.md §6.5).
+      class DuplicateBinding < StandardError
+        attr_reader :name
+
+        def initialize(name)
+          @name = name
+          super("identifier already bound: #{name}")
+        end
+      end
+
+      attr_reader :parent
+
+      def initialize(parent = nil)
+        @vars = {}
+        @parent = parent
+      end
+
+      # Unchecked insert, for interpreter-internal names (__dir__, built-ins, …).
+      def define(name, value)
+        @vars[name] = value
+        self
+      end
+
+      # Insert a pattern binding, rejecting a duplicate binder. Only this env's
+      # own scope is checked: a binder may shadow a name from a parent env, but
+      # must be unique within one pattern/clause.
+      def bind(name, value)
+        raise DuplicateBinding, name if @vars.key?(name)
+
+        @vars[name] = value
+      end
+
+      def lookup(name)
+        if @vars.key?(name)
+          @vars[name]
+        elsif @parent
+          @parent.lookup(name)
+        else
+          :__unbound__
+        end
+      end
+
+      def child
+        Env.new(self)
+      end
+    end
+  end
+end

data/lib/fusion/interpreter/error_val.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# === Interpreter internals ===
+#
+# An error value, always carrying a payload (any JSON-like Fusion value).
+
+module Fusion
+  class Interpreter
+    class ErrorVal
+      attr_reader :payload
+
+      def initialize(payload)
+        @payload = payload
+        @internal = false
+      end
+
+      # Whether this is an interpreter-produced error (vs. a user-constructed
+      # `!expr`). Governs serialization — see docs/user/reference.md §9.3.
+      def internal_error?
+        @internal
+      end
+
+      # Build an interpreter-produced error with the standardized payload shape
+      # documented in docs/user/reference.md §6.5.
+      def self.internal(kind:, location:, operation:, input:, message: nil)
+        error = new(
+          "kind" => kind,
+          "location" => location,
+          "operation" => operation,
+          "input" => input,
+          **(message ? { "message" => message } : {})
+        )
+
+        # Mark as "@internal" to activate lenient serialization.
+        error.instance_variable_set(:@internal, true)
+
+        error
+      end
+
+      def inspect
+        "!#{payload.inspect}"
+      end
+
+      def to_s
+        inspect
+      end
+    end
+  end
+end

data/lib/fusion/interpreter/file_thunk.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+# === Interpreter internals ===
+#
+# Lazy, memoized reference to a file's value (a "thunk" / promise).
+
+module Fusion
+  class Interpreter
+    class FileThunk
+      def initialize(loader, abspath)
+        @loader = loader
+        @abspath = abspath
+        @state = :unforced # :unforced | :forcing | :done
+        @value = nil
+      end
+
+      def force
+        case @state
+        when :done then @value
+        when :forcing
+          # We are already evaluating this file and were asked for it again
+          # without any intervening function boundary => non-productive data cycle.
+          ErrorVal.internal(
+            kind: "reference_error",
+            location: @loader.file_location(@abspath),
+            operation: "forcing a file reference",
+            input: @abspath,
+            message: "non-productive data cycle"
+          )
+        else
+          @state = :forcing
+          @value = @loader.evaluate_file(@abspath)
+          @state = :done
+          @value
+        end
+      end
+    end
+  end
+end

data/lib/fusion/interpreter/func.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# === Interpreter internals ===
+#
+# A function closes over the environment in which it was defined.
+
+module Fusion
+  class Interpreter
+    class Func
+      attr_reader :clauses, :env
+
+      def initialize(clauses, env)
+        @clauses = clauses # [AST::Clause, ...]
+        @env = env
+      end
+
+      def inspect
+        "<func/#{clauses.length}>"
+      end
+    end
+  end
+end

data/lib/fusion/interpreter/native_func.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# === Interpreter internals ===
+#
+# A native (Ruby-implemented) function. Apply treats it like a Func.
+
+module Fusion
+  class Interpreter
+    class NativeFunc
+      attr_reader :name, :fn
+
+      def initialize(name, fn)
+        @name = name
+        @fn = fn
+      end
+
+      def inspect
+        "<builtin #{name}>"
+      end
+    end
+  end
+end