ruspea_lang 0.1.1

data/lib/ruspea/language/ruby.rb

@@ -0,0 +1,36 @@
+module Ruspea::Language
+  class Ruby < Ruspea::Runtime::Env
+    # This method was copied as is from:
+    # https://github.com/rails/rails/blob/66cabeda2c46c582d19738e1318be8d59584cc5b/activesupport/lib/active_support/inflector/methods.rb#L271
+    def constantize(camel_cased_word)
+      names = camel_cased_word.split("::")
+
+      # Trigger a built-in NameError exception including the ill-formed constant in the message.
+      Object.const_get(camel_cased_word) if names.empty?
+
+      # Remove the first blank element in case of '::ClassName' notation.
+      names.shift if names.size > 1 && names.first.empty?
+
+      names.inject(Object) do |constant, name|
+        if constant == Object
+          constant.const_get(name)
+        else
+          candidate = constant.const_get(name)
+          next candidate if constant.const_defined?(name, false)
+          next candidate unless Object.const_defined?(name)
+
+          # Go down the ancestors to check if it is owned directly. The check
+          # stops when we reach Object or the end of ancestors tree.
+          constant = constant.ancestors.inject(constant) do |const, ancestor|
+            break const    if ancestor == Object
+            break ancestor if ancestor.const_defined?(name, false)
+            const
+          end
+
+          # owner is in Object, so raise
+          constant.const_get(name, false)
+        end
+      end
+    end
+  end
+end

data/lib/ruspea/printer.rb

@@ -0,0 +1,54 @@
+module Ruspea
+  class Printer
+    include Ruspea::Runtime
+
+    def call(value)
+      case value
+      when Ruspea::Interpreter::Form
+        call(value.value)
+      when String
+        value.inspect
+      when Numeric
+        value.inspect
+      when Sym
+        value.to_s
+      when List
+        print_list(value)
+      when Lm
+        print_fn(value)
+      else
+        value.inspect
+      end
+    end
+
+    private
+
+    def print_list(list)
+      count = list.count
+
+      printed = list
+        .take(10)
+        .to_a
+        .map { |intern| call(intern) }
+        .join(" ")
+
+      if count > 10
+        "(#{printed} ...) # count: #{count}"
+      else
+        "(#{printed})"
+      end
+    end
+
+    def print_fn(fn)
+      params = fn.params.map { |param| call(param) }.join(" ")
+      body =
+        if fn.body.respond_to?(:call)
+          "#- internal -#\n  #{fn.body.inspect}"
+        else
+          body = fn.body.to_a.map { |exp| call(exp) }.join("\n  ")
+        end
+
+      "(fn [#{params}]\n  #{body})"
+    end
+  end
+end

data/lib/ruspea/repl/loop.rb

@@ -0,0 +1,85 @@
+module Ruspea::Repl
+  class Loop
+    include Ruspea::Interpreter
+
+    def initialize
+      @reader = Reader.new
+      @evaler = Evaler.new
+      @printer = Ruspea::Printer.new
+      @env = Ruspea::Runtime::Env.new(Ruspea::Language::Core.new)
+
+      load_repl(@env)
+    end
+
+    def run(input: STDIN, env: nil)
+      trap "SIGINT" do
+        puts "See you soon."
+        exit(130)
+      end
+
+      env ||= @env
+      prompt_back
+
+      while(line = input.gets)
+        begin
+          interprete(line.chomp, env)
+          prompt_back
+        rescue Ruspea::Error::Standard => e
+          print_error e
+        rescue StandardError => e
+          puts "A Ruby exception was raised. Inspect it? Y/n"
+          yes = !["n", "no"].include?(input.gets.chomp.downcase)
+          if yes
+            puts "Error: #{e.message}\nBacktrace:\n"
+            puts "\s\s#{e.backtrace.join("\n\s\s")}"
+          end
+          prompt_back
+        end
+      end
+
+      puts "See you soon."
+    end
+
+    private
+
+    def load_repl(env)
+      Dir.glob(
+        File.expand_path("../*.rsp", __FILE__)).each do |file|
+          puts "loading repl: #{Pathname.new(file).basename}"
+          _, forms = @reader.call(File.read(file))
+          @evaler.call(forms, context: env)
+        end
+      puts "repl loaded."
+    end
+
+    def prompt_back(ns: "#user")
+      puts ""
+      print "#{ns}=> "
+    end
+
+    def print_error(e)
+      puts e.class
+      puts e.message
+      prompt_back
+    end
+
+    def should_exit?(env)
+      env.call Ruspea::Runtime::Sym.new("%repl_should_exit?")
+    rescue Ruspea::Error::Resolution
+      false
+    end
+
+    def interprete(line, env)
+      _, forms = @reader.call(line)
+      forms.each do |expression|
+        # puts "read: "
+        # pp expression
+        result = @evaler.call(expression, context: env)
+        # puts "evaled: "
+        # pp result
+        Process.kill("SIGINT", Process.pid) if should_exit?(env)
+        print @printer.call(result)
+      end
+    end
+  end
+end

data/lib/ruspea/repl/repl.rsp

@@ -0,0 +1,2 @@
+(def exit (fn [] (%ctx %repl_should_exit? true)))
+(def bye exit)

data/lib/ruspea/runtime/env.rb

@@ -0,0 +1,119 @@
+require "singleton"
+
+module Ruspea::Runtime
+  class Env
+    class Empty
+      include Ruspea::Error
+      include Singleton
+
+      def initialize(*_)
+      end
+
+      def define(*_)
+        nil
+      end
+
+      def lookup(sym)
+        raise(Resolution.new(sym))
+      end
+
+      def eql?(other)
+        self == other
+      end
+
+      def around(env)
+        env
+      end
+
+      def ==(other)
+        return true if other.is_a? Empty
+        false
+      end
+    end
+
+    include Ruspea::Error
+
+    def initialize(context = nil, table = nil)
+      @table =
+        if table.nil?
+          {}
+        else
+          table.dup
+        end
+      @context = context || Empty.instance
+
+      @fn = Fn.new(fn_define, fn_fetch)
+    end
+
+    def define(sym, value)
+      @table[sym] = value
+    end
+
+    def lookup(sym)
+      @table.fetch(sym) { @context.lookup(sym) }
+    end
+
+    def call(*args, context: nil, evaler: nil)
+      # evaler will always send an array
+      # to a #call that is not a #arity
+      if args.is_a?(Array) && args.length == 1
+        args = args.first
+      end
+      @fn.call(*args, context: context, evaler: evaler)
+    end
+
+    def around(env)
+      new_context = env
+        .context
+        .around(self)
+
+      Env.new(new_context, env.table)
+    end
+
+    def eql?(other)
+      self == other
+    end
+
+    def ==(other)
+      return false if self.class != other.class
+      @table == other.table && @context == other.context
+    end
+
+    def hash
+      @table.hash + @context.hash + :rsp_env.hash
+    end
+
+    def inspect
+      @table.map { |k, v|
+        "#{k} => #{v}"
+      }
+    end
+
+    protected
+
+    attr_accessor :table, :context
+
+    private
+
+    def fn_define
+      @fn_define ||= Lm.new(
+        params: [Sym.new("sym"), Sym.new("val")],
+        body: ->(env, _) {
+          define(
+            env.lookup(Sym.new("sym")),
+            env.lookup(Sym.new("val"))
+          )
+        }
+      )
+    end
+
+    def fn_fetch
+      @fn_fetch ||= Lm.new(
+        params: [Sym.new("sym")],
+        body: ->(env, _) {
+          lookup env.lookup(Sym.new("sym"))
+        }
+      )
+    end
+  end
+end

data/lib/ruspea/runtime/fn.rb

@@ -0,0 +1,23 @@
+module Ruspea::Runtime
+  class Fn
+    def initialize(*lambdas)
+      @arities = {}
+
+      lambdas.each { |lm| add lm }
+    end
+
+    def add(lm)
+      arities[lm.arity] = lm
+    end
+
+    def call(*args, context: nil, evaler: nil)
+      arities
+        .fetch(args.length)
+        .call(*args, context: context, evaler: evaler)
+    end
+
+    private
+
+    attr_reader :arities
+  end
+end

data/lib/ruspea/runtime/list.rb

@@ -0,0 +1,67 @@
+module Ruspea::Runtime
+  class List
+    attr_reader :head, :tail, :count
+
+    def self.create(*items)
+      return Nill.instance if items.length == 0
+
+      new items[0], create(*items[1..items.length]), count: items.length
+    end
+
+    def initialize(head, tail = Nill.instance, count: 0)
+      @head = head
+      @tail = tail
+      @count = count
+    end
+
+    def cons(el)
+      self.class.new el, self, count: @count + 1
+    end
+
+    def car
+      head
+    end
+
+    def cdr
+      tail
+    end
+
+    def take(amount, from = self)
+      return Nill.instance if amount == 0 || from.empty?
+
+      from
+        .take(amount - 1, from.tail)
+        .cons(from.head)
+    end
+
+    def empty?
+      false
+    end
+
+    def to_a(list = self, array = [])
+      return array if list.empty?
+
+      to_a(
+        list.tail,
+        array + [list.head])
+    end
+
+    def eq?(other)
+      self == other
+    end
+
+    def eql?(other)
+      self == other
+    end
+
+    def ==(other)
+      return false if self.class != other.class
+      head == other.head && tail == other.tail
+    end
+
+    def inspect
+      @printer ||= Ruspea::Printer.new
+      @printer.call self
+    end
+  end
+end

data/lib/ruspea/runtime/lm.rb

@@ -0,0 +1,74 @@
+module Ruspea::Runtime
+  class Lm
+    attr_reader :arity, :params, :body
+
+    def initialize(params: [], body: Nill.instance, closure: Env::Empty.instance)
+      @params = params
+      @arity = params.length
+      @body = body
+      @closure = closure
+    end
+
+    def call(*args, context: nil, evaler: nil)
+      context ||= Env::Empty.instance
+      evaler ||= Ruspea::Interpreter::Evaler.new
+
+      env, callable = env_and_callable_body(args, context, evaler)
+      env.define Sym.new("%ctx"), context
+
+      callable.call closure.around(env), evaler, args
+    end
+
+    private
+
+    attr_reader :closure
+
+    def env_and_callable_body(args, context, evaler)
+      if body.respond_to? :call
+        [
+          environment_with(args, context, evaler: ->(arg, _) { arg }),
+          ->(environment, evaler, _) { body.call environment, evaler }
+        ]
+      else
+        if args.length != arity
+          raise Ruspea::Error::Arity.new(arity, args.length)
+        end
+
+        [
+          environment = environment_with(args, context, evaler: evaler),
+          ->(environment, evaler, args) {
+            evaluate(body, context: environment, evaler: evaler)
+          }
+        ]
+      end
+    end
+
+    def environment_with(args, context, evaler:)
+      env = Env.new(context)
+      args.each_with_index.reduce(env) { |env, tuple|
+        arg, idx = tuple
+        sym =
+          if arg.is_a?(Ruspea::Interpreter::Form)
+            arg.value
+          else
+            arg
+          end
+
+        env.tap { |e|
+          e.define(
+            params[idx], evaler.call(sym, context: context))
+        }
+      }
+    end
+
+    def evaluate(forms, result = nil, evaler:, context:)
+      return result if forms.empty?
+
+      evaluate(
+        forms.tail,
+        evaler.call(forms.head, context: context),
+        evaler: evaler,
+        context: context)
+    end
+  end
+end