fusion-lang 0.0.1.alpha1 → 0.0.1.alpha2

data/examples/ends.fsn

@@ -0,0 +1,4 @@
+(
+  [first, ..., last] => [first, last],
+  _ => !{ "message": "Requires an array with at least 2 elements!" }
+)

data/examples/palindrome.fsn

@@ -1,8 +1,9 @@
 # Check, whether input string or array is a palindrome
 (
+  n ? @Number => n | @toString | @,
   s ? @String => s | @chars | @,
   []  => "palindrome",
   [_] => "palindrome",
-  [_, ...rest, _] ? ([first, ..., last] => [first, last] | @equals) => rest | @,
+  [_, ...rest, _] ? @ends | @equals => rest | @,
   _   => "not a palindrome"
 )

data/exe/fusion

@@ -3,55 +3,28 @@
 
 # Fusion CLI entrypoint.
 #
-# A file contains exactly one value. A file is "executable" if that value is a
-# function; the runtime computes  STDIN | thatFunction  and prints the result.
-#
 # Usage:
 #   echo '[1,2,3]' | fusion path/to/main.fsn
 #   fusion path/to/main.fsn '<json-input>'        # input as an argument
 #   fusion -e '(n => [n,2] | @multiply)' '21'     # inline program
+#   fusion --stream path/to/main.fsn              # NDJSON in, NDJSON out
+#   fusion --repl                                 # interactive expressions/statements
+#
+# Run `fusion --help` for the input/output modes (--input / --output / -!).
 
 require_relative "../lib/fusion"
 
-args = ARGV.dup
-inline = nil
-if args[0] == "-e"
-  inline = args[1]
-  program_path = nil
-  explicit_input = args[2]
-else
-  program_path = args[0]
-  explicit_input = args[1]
+if ARGV.intersect?(["--help", "-h"])
+  puts Fusion::CLI::Options::USAGE
+  exit 0
 end
 
-stdlib = File.expand_path("../stdlib", __dir__)
-interp = Fusion::Interpreter.new(stdlib_dir: (Dir.exist?(stdlib) ? stdlib : nil))
-
-# Determine the program function value.
-program_value =
-  if inline
-    ast = Fusion::Parser.parse_file(inline)
-    env = interp.root_env.child
-    env.define("__dir__", Dir.pwd)
-    interp.eval_expr(ast, env)
-  else
-    abort("usage: fusion <file.fsn> [json-input]   or   fusion -e '<src>' [json-input]") unless program_path
-    interp.load_file(File.expand_path(program_path)).force
-  end
-
-# Read input: explicit arg wins, else stdin.
-input_text = explicit_input || ($stdin.tty? ? "" : $stdin.read)
-input_text = "null" if input_text.nil? || input_text.strip.empty?
-input_value = Fusion::JsonInput.parse(input_text)
-
-result = interp.apply(program_value, input_value)
-
-if Fusion.error?(result)
-  # Print only the payload (as JSON) to stderr; stdout stays empty so that
-  # shell pipelines can rely on "stdout has the result, or there isn't one".
-  $stderr.puts Fusion::Serializer.to_json(result.payload)
-  exit 1
-else
-  puts Fusion::Serializer.to_json(result)
-  exit 0
+options = begin
+  Fusion::CLI::Options.parse(ARGV)
+rescue Fusion::CLI::Options::UsageError => err
+  # A command-line misuse happens before the input/output contract begins, so
+  # it is plain text on stderr, not a payloaded error.
+  abort("fusion: #{err.message}\n\n#{Fusion::CLI::Options::USAGE}")
 end
+
+Fusion::CLI.run(options)

data/lib/fusion/ast.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+# === Data Structure ===
+#
+# An AST::Expression is
+# - output of the parser
+# - input of the interpreter
+
+require_relative "typed_data"
+require_relative "atom"
+
+module Fusion
+  module AST
+    # 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/
+
+    # 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
+    # mixed into all of its members at the bottom of its body, so the module
+    # doubles as a marker: a field typed `Expression` accepts any expression
+    # node, `Pattern` any pattern node.
+    module Expression; end
+    module Pattern; end
+    module Statement; end
+
+    # 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
+
+    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
+        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 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]
+
+      constants.each do |name|
+        node = const_get(name)
+        node.include(self) if node.is_a?(Class) && node < Data
+      end
+    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
+        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
+        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
+
+      constants.each do |name|
+        node = const_get(name)
+        node.include(self) if node.is_a?(Class) && node < Data
+      end
+    end
+
+    module Statement
+      # The only statement. Only allowed in the REPL. `name = expression`.
+      Assignment = TypedData.define(name: Identifier, expression: Expression)
+
+      constants.each do |name|
+        node = const_get(name)
+        node.include(self) if node.is_a?(Class) && node < Data
+      end
+    end
+  end
+end

data/lib/fusion/atom.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+# === Value ===
+#
+# An atomic runtime value.
+
+require_relative "typed_data"
+require_relative "null"
+
+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.is_a?(Integer) || v.is_a?(Float) || v.is_a?(String)
+  }
+end

data/lib/fusion/cli/decoder.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+# === CLI internals ===
+
+require "json"
+require_relative "../wire_pair"
+
+module Fusion
+  module CLI
+    module Decoder
+      extend self
+
+      ENVELOPE_SHAPES = {
+        array: "[0, _] or [1, _]",
+        object: '{"value": _} or {"error": _}',
+      }.freeze
+
+      # String -> WirePair
+      # Doesn't support mode `:unix`
+      def decode(text, mode:)
+        case mode
+        when :bang
+          decode_bang(text)
+        when :array
+          decode_envelope(text, mode) do |raw|
+            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
+          end
+        when :object
+          decode_envelope(text, mode) do |raw|
+            next unless raw.is_a?(Hash) && raw.size == 1
+
+            if raw.key?("value") then [0, raw["value"]]
+            elsif raw.key?("error") then [1, raw["error"]]
+            end
+          end
+        else
+          raise Unreachable, "Unknown input mode #{mode}"
+        end
+      end
+
+      private
+
+      # bang: a leading "!" marks an error value; its payload is the JSON after
+      # the "!". A lone "!" is the error !null, mirroring the language's bare !.
+      def decode_bang(text)
+        stripped = text.strip
+        return WirePair.new(status: 0, data: text) unless stripped.start_with?("!")
+
+        payload = stripped.delete_prefix("!")
+        WirePair.new(status: 1, data: payload.strip.empty? ? "null" : payload)
+      end
+
+      # array/object: the input is an envelope around the actual value. The block
+      # inspects the JSON (raw Ruby, so nulls are nil) and returns [status, inner]
+      # or nil for a wrong shape. The inner is re-emitted as JSON text for the
+      # pair; invalid JSON falls through to `parse` as a value to fail on, so the
+      # syntax_error stays in one place.
+      def decode_envelope(text, mode)
+        raw = JSON.parse(text)
+        status, inner = yield(raw)
+        return WirePair.new(status: status, data: JSON.generate(inner)) if status
+
+        WirePair.new(status: 1, data: JSON.generate(
+          "kind" => "argument_error",
+          "location" => "input",
+          "operation" => "decoding input",
+          "input" => raw,
+          "message" => "expected #{ENVELOPE_SHAPES.fetch(mode)}"
+        ))
+      rescue JSON::ParserError
+        # TODO: BUG ???
+        WirePair.new(status: 0, data: text)
+      end
+    end
+  end
+end

data/lib/fusion/cli/encoder.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# === CLI internals ===
+
+module Fusion
+  module CLI
+    module Encoder
+      extend self
+
+      # WirePair -> String
+      # Doesn't support mode `:unix`
+      def encode(wire_pair, mode:)
+        case mode
+        when :bang
+          bang = wire_pair.status.zero? ? "" : "!"
+          "#{bang}#{wire_pair.data}"
+        when :array
+          "[#{wire_pair.status},#{wire_pair.data}]"
+        when :object
+          key = wire_pair.status.zero? ? "value" : "error"
+          "{\"#{key}\":#{wire_pair.data}}"
+        else
+          raise Unreachable, "Unknown output mode #{mode}"
+        end
+      end
+    end
+  end
+end

data/lib/fusion/cli/options.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+# === CLI internals ===
+#
+# Input: ARGV
+# Output: Options (use case, input/output modes, program, input)
+#
+# A misuse of the command line is a UsageError, reported as plain text on
+# stderr by exe/fusion — it happens before the input/output contract begins,
+# so it is not a payloaded Fusion error.
+
+module Fusion
+  module CLI
+    class Options
+      class UsageError < StandardError; end
+
+      USAGE = <<~TEXT
+        usage: fusion [options] <file.fsn> [json-input]
+               fusion [options] -e '<source>' [json-input]
+               fusion --repl
+
+        use cases:
+          (default)       pipe: apply the program to one input
+          --stream        apply the program to each line of an NDJSON stream
+          --repl          interactive expressions and `identifier = expression`
+
+        options:
+          -e '<source>'   inline program instead of a file
+          --input MODE    how the input marks an error value
+          --output MODE   how the output marks an error value
+          -!              treat the input as an error value (unix input mode only)
+
+        modes: unix, bang, array, object
+          unix    pipe only (default there): plain JSON; output: stdout/exit 0
+                  for values, stderr/exit 1 for error payloads
+          bang    a leading "!" marks an error value (default for --stream)
+          array   [0, value] marks a value, [1, payload] an error
+          object  {"value": _} marks a value, {"error": _} an error
+      TEXT
+
+      MODES = %w[unix bang array object].freeze
+
+      attr_reader :use_case, :input_mode, :output_mode, :inline_source, :program_path, :explicit_input
+
+      def initialize(use_case:, input_mode:, output_mode:, inline_source:, program_path:, explicit_input:, error_input:)
+        @use_case = use_case
+        @input_mode = input_mode
+        @output_mode = output_mode
+        @inline_source = inline_source
+        @program_path = program_path
+        @explicit_input = explicit_input
+        @error_input = error_input
+      end
+
+      def error_input?
+        @error_input
+      end
+
+      def self.parse(argv)
+        arguments = argv.dup
+        use_case = :pipe
+        input_mode = nil
+        output_mode = nil
+        error_input = false
+        inline_source = nil
+        positional = []
+
+        until arguments.empty?
+          argument = arguments.shift
+          case argument
+          when "--stream" then use_case = :stream
+          when "--repl" then use_case = :repl
+          when "--input" then input_mode = shift_mode(arguments, "--input")
+          when "--output" then output_mode = shift_mode(arguments, "--output")
+          when "-!" then error_input = true
+          when "-e"
+            inline_source = arguments.shift
+            raise UsageError, "-e requires a source argument" if inline_source.nil?
+          when /\A--/
+            raise UsageError, "unknown option #{argument}"
+          else
+            # Anything else is positional. A single leading "-" stays positional
+            # so negative numbers work as the json-input argument: fusion f.fsn -5
+            positional << argument
+          end
+        end
+
+        validate(use_case, input_mode, output_mode, error_input, inline_source, positional)
+      end
+
+      # Check the flag combination against the use case and fill in defaults.
+      def self.validate(use_case, input_mode, output_mode, error_input, inline_source, positional)
+        case use_case
+        when :repl
+          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 = explicit_input = nil
+        when :stream
+          input_mode ||= :bang
+          output_mode ||= :bang
+          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, "--stream reads its input from stdin, not an argument" unless positional.empty?
+          explicit_input = nil
+        when :pipe
+          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
+          explicit_input = positional.shift
+          raise UsageError, "too many arguments: #{positional.join(' ')}" unless positional.empty?
+        else
+          raise Unreachable, "Unknown use case #{use_case}"
+        end
+
+        new(
+          use_case: use_case,
+          input_mode: input_mode,
+          output_mode: output_mode,
+          inline_source: inline_source,
+          program_path: program_path,
+          explicit_input: explicit_input,
+          error_input: error_input
+        )
+      end
+
+      def self.shift_mode(arguments, flag)
+        mode = arguments.shift
+        unless MODES.include?(mode)
+          raise UsageError, "#{flag} expects one of: #{MODES.join(', ')} (got #{mode.nil? ? 'nothing' : mode})"
+        end
+        mode.to_sym
+      end
+
+      private_class_method :validate, :shift_mode
+    end
+  end
+end

data/lib/fusion/cli/parser.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# === CLI internals ===
+
+require "json"
+
+module Fusion
+  module CLI
+    module Parser
+      extend self
+
+      # WirePair -> runtime value
+      def parse(wire_pair)
+        value = convert(JSON.parse(wire_pair.data))
+        wire_pair.status == 1 ? Interpreter::ErrorVal.new(value) : value
+      rescue JSON::ParserError
+        Interpreter::ErrorVal.internal(
+          kind: "syntax_error",
+          location: "input",
+          operation: "parsing input as JSON",
+          input: wire_pair.data,
+          message: "input is not valid JSON"
+        )
+      end
+
+      private
+
+      def convert(ruby_value)
+        case ruby_value
+        when nil then NULL
+        when Array then ruby_value.map { |item| convert(item) }
+        when Hash then ruby_value.transform_values { |value| convert(value) }
+        else ruby_value
+        end
+      end
+    end
+  end
+end

data/lib/fusion/cli/repl.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+# === CLI internals ===
+
+require_relative "serializer"
+require_relative "encoder"
+require_relative "../interpreter/env"
+
+module Fusion
+  module CLI
+    class Repl
+      PROMPT = "fsn> "
+      CONTINUATION_PROMPT = "...> "
+
+      # REPL entries report errors with the same location as inline (`-e`) code.
+      LOCATION = "code <inline>"
+
+      def run
+        require "reline"
+        $stdout.sync = true
+        Reline.output = $stderr
+        Reline.prompt_proc = proc do |lines|
+          lines.each_index.map { |i| i.zero? ? PROMPT : CONTINUATION_PROMPT }
+        end
+
+        environment = Interpreter::Env.new.define("__dir__", Dir.pwd)
+
+        loop do
+          buffer = begin
+            Reline.readmultiline(PROMPT, true) { complete?(_1) }
+          rescue Interrupt
+            $stderr.puts("^C") # discard the half-typed entry and re-prompt
+            next
+          end
+
+          break if buffer.nil? # Ctrl-D on an empty line ends the session
+          next if buffer.strip.empty?
+
+          $stdout.puts(handle(buffer, environment))
+        end
+      end
+
+      def complete?(buffer)
+        return true if buffer.strip.empty?
+
+        ast = Fusion::Parser.parse_repl(buffer, location: LOCATION)
+        ast.is_a?(AST::Expression) || ast.is_a?(AST::Statement::Assignment)
+      end
+
+      def handle(buffer, environment)
+        ast = Fusion::Parser.parse_repl(buffer, location: LOCATION)
+        runtime_value = evaluate(ast, environment)
+        wire_pair = Serializer.serialize(runtime_value, lenient: true)
+        Encoder.encode(wire_pair, mode: :bang)
+      end
+
+      private
+
+      def evaluate(ast, environment)
+        case ast
+        when AST::Expression
+          Interpreter.safe_evaluate(ast, environment)
+        when AST::Statement::Assignment
+          value = Interpreter.safe_evaluate(ast.expression, environment)
+          environment.define(ast.name, value)
+          value
+        else
+          raise Unreachable, "Unhandled AST node #{ast.class}"
+        end
+      end
+    end
+  end
+end

data/lib/fusion/cli/serializer.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+# === CLI internals ===
+
+require_relative "../wire_pair"
+
+module Fusion
+  module CLI
+    module Serializer
+      extend self
+
+      # runtime value -> WirePair
+      # Only use "lenient: true" in the REPL!
+      def serialize(runtime_value, lenient: false)
+        message = catch(:unserializable) do
+          if runtime_value.is_a?(Interpreter::ErrorVal)
+            data = convert(runtime_value.payload, lenient: lenient || runtime_value.internal_error?).to_json
+            return WirePair.new(status: 1, data: data)
+          else
+            return WirePair.new(status: 0, data: convert(runtime_value, lenient: lenient).to_json)
+          end
+        end
+
+        internal_error = Interpreter::ErrorVal.internal(
+          kind: "serialization_error",
+          location: "output",
+          operation: "serializing result",
+          input: runtime_value,
+          message: message
+        )
+
+        serialize(internal_error, lenient: true)
+      end
+
+      private
+
+      # Use "lenient: true" only for best-effort serialization of internal errors and the REPL.
+      def convert(runtime_value, lenient: false)
+        case runtime_value
+        when NULL
+          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>"
+        when Array
+          runtime_value.map { |item| convert(item, lenient:) }
+        when Hash
+          runtime_value.transform_values { |value| convert(value, lenient:) }
+        when Interpreter::Func, Interpreter::NativeFunc
+          throw(:unserializable, "cannot serialize a function") unless lenient
+
+          "<function>"
+        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
+        else
+          raise Unreachable, "Unhandled type in convert: #{runtime_value.class}"
+        end
+      end
+    end
+  end
+end