rbl 0.0.5 → 0.0.6

data/lib/rubylisp/function.rb

@@ -0,0 +1,154 @@
+require 'rubylisp/types'
+
+module RubyLisp
+  class Arity
+    attr_accessor :body, :required_args, :rest_args
+
+    def initialize(ast)
+      unless list? ast
+        raise RuntimeError,
+          "Invalid signature #{arity}; expected a list."
+      end
+
+      bindings, *body = ast
+
+      unless vector? bindings
+        raise RuntimeError,
+          "Bindings must be a vector; got #{body.class}."
+      end
+
+      bindings.each do |binding|
+        unless binding.class == Symbol
+          raise RuntimeError,
+            "Each binding must be a symbol; got #{binding.class}."
+        end
+      end
+
+      # bindings is now an array of strings (symbol names)
+      bindings = bindings.map(&:value)
+
+      ampersand_indices = bindings.to_list.indices {|x| x == '&'}
+      if ampersand_indices.any? {|i| i != bindings.count - 2}
+        raise RuntimeError,
+          "An '&' can only occur right before the last binding."
+      end
+
+      @required_args = bindings.take_while {|binding| binding != '&'}
+      @rest_args = bindings.drop_while {|binding| binding != '&'}.drop(1)
+      @body = body
+    end
+  end
+
+
+  class Function < Proc
+    attr_accessor :name, :env, :bindings, :body, :is_macro, :lambda
+
+    def initialize(name, env, asts, &block)
+      super()
+      @name = name
+      @env = env
+      @arities = construct_arities(asts)
+      @is_macro = false
+      @lambda = block
+    end
+
+    def construct_arities(asts)
+      arities_hash = asts.each_with_object({'arities' => [],
+                                            'required' => 0}) do |ast, result|
+        arity = Arity.new(ast)
+
+        if arity.rest_args.empty?
+          # Prevent conflicts like [x] vs. [y]
+          if result['arities'].any? {|existing|
+            existing.required_args.count == arity.required_args.count &&
+            existing.rest_args.empty?
+          }
+            raise RuntimeError,
+                  "Can't have multiple overloads with the same arity."
+          end
+
+          # Prevent conflicts like [& xs] vs. [x]
+          if result['rest_required']
+            unless arity.required_args.count <= result['rest_required']
+            raise RuntimeError,
+                  "Can't have a fixed arity function with more params than a " +
+                  "variadic function."
+            end
+          end
+        else
+          # Prevent conflicts like [x] vs. [& xs]
+          if arity.required_args.count < result['required']
+            raise RuntimeError,
+                  "Can't have a fixed arity function with more params than a " +
+                  "variadic function."
+          end
+
+          # Prevent conflicts like [x & xs] vs. [x y & ys]
+          if result['arities'].any? {|existing| !existing.rest_args.empty?}
+            raise RuntimeError,
+                  "Can't have more than one variadic overload."
+          end
+
+          result['rest_required'] = arity.required_args.count
+        end
+
+        result['required'] = [result['required'], arity.required_args.count].max
+        result['arities'] << arity
+      end
+
+      arities_hash['arities']
+    end
+
+    def get_arity(args)
+      # Assert that there are enough arguments provided for the arities we have.
+      sexp = list [Symbol.new(@name), *args]
+      variadic = @arities.find {|arity| !arity.rest_args.empty?}
+      fixed_arities = @arities.select {|arity| arity.rest_args.empty?}
+      fixed = fixed_arities.find {|arity| arity.required_args.count == args.count}
+
+      # Return the arity most appropriate for the number of args provided.
+      if fixed
+        fixed
+      elsif variadic
+        assert_at_least_n_args sexp, variadic.required_args.count
+        variadic
+      else
+        raise RuntimeError,
+              "Wrong number of args (#{args.count}) passed to #{@name}"
+      end
+    end
+
+    def gen_env(arity, args, env)
+      # set out_env to the current namespace so that `def` occurring within
+      # the fn's environment will define things in the namespace in which the
+      # function is called
+      out_env = env.out_env || env.find_namespace
+      env = Environment.new(outer: @env, out_env: out_env)
+      # so the fn can call itself recursively
+      env.set(@name, self)
+
+      if arity.rest_args.empty?
+        # bind values to the required args
+        arity.required_args.zip(args).each do |k, v|
+          env.set(k, v)
+        end
+      else
+        # bind values to the required args (the rest args are skipped here)
+        arity.required_args.zip(args).each do |k, v|
+          env.set(k, v)
+        end
+
+        # bind the rest argument to the remaining arguments or nil
+        rest_args = if args.count > arity.required_args.count
+                      args[arity.required_args.count..-1].to_list
+                    else
+                      nil
+                    end
+
+        env.set(arity.rest_args.first, rest_args)
+      end
+
+      env
+    end
+  end
+end

data/lib/rubylisp/parser.rb

@@ -8,18 +8,18 @@ module RubyLisp
     module_function
 
     def read input
-      RubyLisp::Reader.read_str input
+      Reader.read_str input
     end
 
     def eval_ast input, env
-      RubyLisp::Evaluator.eval_ast input, env
+      Evaluator.eval_ast input, env
     end
 
     def print input
-      RubyLisp::Printer.pr_str input
+      Printer.pr_str input
     end
 
-    def parse input, env = RubyLisp::Environment.new.stdlib
+    def parse input, env = Environment.new.stdlib
       ast = read input
       result = eval_ast ast, env
       print result

data/lib/rubylisp/printer.rb

@@ -18,11 +18,14 @@ module RubyLisp
           pr_str x.to_hash
         when Hamster::List
           "(#{x.map {|item| pr_str(item)}.join(' ')})"
-        when RubyLisp::List
-          "(#{x.value.map {|item| pr_str(item)}.join(' ')})"
-        when RubyLisp::Symbol, RubyLisp::String, RubyLisp::Int, RubyLisp::Float,
-             RubyLisp::Boolean, RubyLisp::Keyword
+        when Function
+          "#<#{x.is_macro ? 'Macro' : 'Function'}: #{x.name}>"
+        when Symbol
           x.value
+        when Value
+          x.value.inspect
+        when Object::Symbol
+          ":#{x.name}"
         else
           x.inspect
         end

data/lib/rubylisp/rbl_readline.rb

@@ -0,0 +1,29 @@
+# adapted from: https://github.com/kanaka/mal/blob/master/ruby/mal_readline.rb
+require 'fileutils'
+require "readline"
+
+$history_loaded = false
+$histfile = "#{ENV['HOME']}/.rbl-history"
+
+# create history file if it doesn't exist already
+FileUtils.touch($histfile)
+
+def _readline(prompt)
+  if !$history_loaded && File.exist?($histfile)
+    $history_loaded = true
+    if File.readable?($histfile)
+      File.readlines($histfile).each {|l| Readline::HISTORY.push(l.chomp)}
+    end
+  end
+
+  if line = Readline.readline(prompt, true)
+    if line.strip.empty? || Readline::HISTORY[-2] == Readline::HISTORY[-1]
+      Readline::HISTORY.pop
+    elsif File.writable?($histfile)
+      File.open($histfile, 'a+') {|f| f.write(line+"\n")}
+    end
+    return line
+  else
+    return nil
+  end
+end

data/lib/rubylisp/reader.rb

@@ -39,29 +39,29 @@ module RubyLisp
       token
     end
 
-    def read_seq(type, end_token, seq=[])
+    def read_seq(type_name, constructor, end_token, seq=[])
       case peek
       when nil
-        raise RubyLisp::ParseError, "Unexpected EOF while parsing #{type}."
+        raise ParseError, "Unexpected EOF while parsing #{type_name}."
       when end_token
         next_token
-        type.new(seq)
+        constructor.call(seq)
       else
         seq << read_form
-        read_seq(type, end_token, seq)
+        read_seq(type_name, constructor, end_token, seq)
       end
     end
 
     def read_list
-      read_seq RubyLisp::List, ')'
+      read_seq 'list', RubyLisp.method(:list), ')'
     end
 
     def read_vector
-      read_seq RubyLisp::Vector, ']'
+      read_seq 'vector', RubyLisp.method(:vec), ']'
     end
 
     def read_hashmap
-      read_seq RubyLisp::HashMap, '}'
+      read_seq 'hash-map', RubyLisp.method(:hash_map), '}'
     end
 
     def read_atom
@@ -70,38 +70,36 @@ module RubyLisp
       when nil
         nil
       when /^\-?\d+$/
-        RubyLisp::Int.new(token.to_i)
+        Value.new(token.to_i)
       when /^\-?\d+\.\d+$/
-        RubyLisp::Float.new(token.to_f)
+        Value.new(token.to_f)
       when /^".*"$/
         # it's safe to use eval here because the tokenizer ensures that
         # the token is an escaped string representation
-        RubyLisp::String.new(eval(token))
+        Value.new(eval(token))
       # it's a little weird that an unfinished string (e.g. "abc) gets
       # tokenized as "", but at least the behavior is consistent ¯\_(ツ)_/¯
       when ""
-        raise RubyLisp::ParseError,
-              "Unexpected EOF while parsing RubyLisp::String."
+        raise ParseError, "Unexpected EOF while parsing string."
       when /^:/
-        RubyLisp::Keyword.new(token[1..-1].to_sym)
+        Value.new(token[1..-1].to_sym)
       when 'nil'
-        RubyLisp::Nil.new
+        Value.new(nil)
       when 'true'
-        RubyLisp::Boolean.new(true)
+        Value.new(true)
       when 'false'
-        RubyLisp::Boolean.new(false)
+        Value.new(false)
       else
-        RubyLisp::Symbol.new(token)
+        Symbol.new(token)
       end
     end
 
     def read_special_form(special)
       form = read_form
       unless form
-        raise RubyLisp::ParseError,
-              "Unexpected EOF while parsing #{special} form."
+        raise ParseError, "Unexpected EOF while parsing #{special} form."
       end
-      RubyLisp::List.new([RubyLisp::Symbol.new(special), form])
+      list [Symbol.new(special), form]
     end
 
     def read_quoted_form
@@ -128,23 +126,23 @@ module RubyLisp
       token = peek
       case token
       when nil
-        raise RubyLisp::ParseError, "Unexpected EOF while parsing metadata."
+        raise ParseError, "Unexpected EOF while parsing metadata."
       when '{'
         next_token
         metadata = read_hashmap
       when /^:/
         kw = read_form
-        metadata = RubyLisp::HashMap.new([kw, RubyLisp::Boolean.new(true)])
+        metadata = hash_map [kw, Value.new(true)]
       else
-        raise RubyLisp::ParseError, "Invalid metadata: '#{token}'"
+        raise ParseError, "Invalid metadata: '#{token}'"
       end
 
       form = read_form
       unless form
-        raise RubyLisp::ParseError, "Unexpected EOF after metadata."
+        raise ParseError, "Unexpected EOF after metadata."
       end
 
-      RubyLisp::List.new([RubyLisp::Symbol.new("with-meta"), form, metadata])
+      list [Symbol.new("with-meta"), form, metadata]
     end
 
     def read_form
@@ -163,11 +161,11 @@ module RubyLisp
         next_token
         read_hashmap
       when ')'
-        raise RubyLisp::ParseError, "Unexpected ')'."
+        raise ParseError, "Unexpected ')'."
       when ']'
-        raise RubyLisp::ParseError, "Unexpected ']'."
+        raise ParseError, "Unexpected ']'."
       when '}'
-        raise RubyLisp::ParseError, "Unexpected '}'."
+        raise ParseError, "Unexpected '}'."
       when "'"
         next_token
         read_quoted_form

data/lib/rubylisp/repl.rb

@@ -1,4 +1,4 @@
-require 'readline'
+require_relative 'rbl_readline'
 require 'rubylisp/environment'
 require 'rubylisp/parser'
 
@@ -7,12 +7,12 @@ module RubyLisp
     module_function
 
     def start
-      env = RubyLisp::Environment.new(namespace: 'user').stdlib.repl
+      env = Environment.new(namespace: 'user').stdlib.repl
 
-      while buf = Readline.readline("#{env.namespace}> ", true)
+      while buf = _readline("#{env.namespace}> ")
         begin
           input = buf.nil? ? '' : buf.strip
-          puts input.empty? ? '' : RubyLisp::Parser.parse(input, env)
+          puts input.empty? ? '' : Parser.parse(input, env)
         rescue => e
           # If an error happens, print it like Ruby would and continue accepting
           # REPL input.

data/lib/rubylisp/types.rb

@@ -1,18 +1,24 @@
+require 'concurrent/atom'
 require 'hamster/core_ext'
 require 'hamster/hash'
 require 'hamster/list'
 require 'hamster/vector'
+require 'rubylisp/function'
+require 'rubylisp/util'
+
+include RubyLisp::Util
 
 # Monkey-patch Ruby symbols to act more like Clojure keywords
 class Symbol
 	def name
-		to_s[1..-1]
+		without_colon = inspect[1..-1]
+    if without_colon[0] == '"' && without_colon[-1] == '"'
+      without_colon[1..-2]
+    else
+      without_colon
+    end
 	end
 
-  def to_s
-    inspect
-  end
-
   def call(target)
     if [Hash, Hamster::Hash].member? target.class
       target[self]
@@ -52,88 +58,29 @@ end
 
 module RubyLisp
   class Value
-    attr_accessor :value, :quoted
+    attr_accessor :value
 
     def initialize(value)
       @value = value
     end
 
-    def quote
-      @quoted = true
-      self
-    end
-
-    def unquote
-      @quoted = false
-      self
-    end
-
     def to_s
       @value.to_s
     end
   end
 
-  class Boolean < Value; end
-  class Float < Value; end
-  class Int < Value; end
-  class Keyword < Value; end
-  class String < Value; end
-
   class ParseError < StandardError; end
   class RuntimeError < StandardError; end
 
-  class HashMap < Value
-    def initialize(seq)
-      if seq.size.odd?
-        raise RubyLisp::ParseError,
-          "A RubyLisp::HashMap must contain an even number of forms."
-      else
-        @value = Hamster::Hash[seq.each_slice(2).to_a]
-      end
-    end
-
-    def quote
-      @value.each {|k, v| k.quote; v.quote}
-      @quoted = true
-      self
-    end
-
-    def unquote
-      @value.each {|k, v| k.unquote; v.unquote}
-      @quoted = false
-      self
-    end
-  end
-
-  class List < Value
-    def initialize(values)
-      @value = values.to_list
-    end
-
-    def quote
-      @value.each(&:quote)
-      @quoted = true
-      self
-    end
-
-    def unquote
-      @value.each(&:unquote)
-      @quoted = false
-      self
-    end
-  end
-
-  class Nil < Value
-    def initialize
-      @value = nil
-    end
-  end
-
   class Symbol < Value
     def to_s
       @value
     end
 
+    def ==(other)
+      other.is_a?(Symbol) && @value == other.value
+    end
+
     def resolve(env)
       # rbl: (.+ 1 2)
       # ruby: 1.+(2)
@@ -151,9 +98,9 @@ module RubyLisp
         first_segment, *segments = @value.split('::')
         first_segment = Object.const_get first_segment
         return segments.reduce(first_segment) do |result, segment|
-          if result.class == Proc
+          if result.is_a? Proc
             # a method can only be in the final position
-            raise RubyLisp::RuntimeError, "Invalid value: #{@value}"
+            raise RuntimeError, "Invalid value: #{@value}"
           elsif /^[A-Z]/ =~ segment
             # get module/class constant
             result.const_get segment
@@ -170,21 +117,43 @@ module RubyLisp
     end
   end
 
-  class Vector < Value
-    def initialize(values)
-      @value = Hamster::Vector.new(values)
+  module Util
+    module_function
+
+    def hash_map(values)
+      if values.size.odd?
+        raise ParseError, "A hash-map must contain an even number of forms."
+      else
+        Hamster::Hash[values.each_slice(2).to_a]
+      end
+    end
+
+    def map?(x)
+      x.is_a? Hamster::Hash
+    end
+
+    def list(values)
+      values.to_list
+    end
+
+    def list?(x)
+      x.is_a? Hamster::List
+    end
+
+    def vec(values)
+      Hamster::Vector.new(values)
+    end
+
+    def vector(*values)
+      Hamster::Vector.new(values)
     end
 
-    def quote
-      @value.each(&:quote)
-      @quoted = true
-      self
+    def vector?(x)
+      x.is_a? Hamster::Vector
     end
 
-    def unquote
-      @value.each(&:unquote)
-      @quoted = false
-      self
+    def sequential?(x)
+      list?(x) || vector?(x)
     end
   end
 end

data/lib/rubylisp/util.rb

@@ -0,0 +1,64 @@
+module RubyLisp
+  module Util
+    module_function
+
+    def assert_number_of_args sexp, num_args
+      fn, *args = sexp
+      fn_name = fn.value
+      unless args.count == num_args
+        raise RuntimeError,
+              "Wrong number of arguments passed to `#{fn_name}`; " +
+              "got #{args.count}, expected #{num_args}."
+      end
+    end
+
+    def assert_at_least_n_args sexp, num_args
+      fn, *args = sexp
+      fn_name = fn.value
+      unless args.count >= num_args
+        raise RuntimeError,
+              "Wrong number of arguments passed to `#{fn_name}`; " +
+              "got #{args.count}, expected at least #{num_args}."
+      end
+    end
+
+    def assert_arg_type sexp, arg_number, arg_type
+      fn = sexp[0]
+      fn_name = fn.value
+      arg = if arg_number == 'last'
+              sexp.last
+            else
+              sexp[arg_number]
+            end
+
+      arg_description = if arg_number == 'last'
+                          'The last argument'
+                        else
+                          "Argument ##{arg_number}"
+                        end
+
+      arg_types = if arg_type.class == Array
+                    arg_type
+                  else
+                    [arg_type]
+                  end
+
+      expected = case arg_types.count
+                 when 1
+                   arg_types.first
+                 when 2
+                   arg_types.join(' or ')
+                 else
+                   last_arg_type = arg_types.pop
+                   arg_types.join(', ') + " or #{last_arg_type}"
+                 end
+
+      if arg_types.none? {|type| arg.is_a? type}
+        raise RuntimeError,
+              "#{arg_description} to `#{fn_name}` must be a " +
+              "#{expected}; got a #{arg.class}."
+      end
+    end
+
+  end
+end

data/lib/rubylisp/version.rb

@@ -1,3 +1,3 @@
 module RubyLisp
-  VERSION = "0.0.5"
+  VERSION = "0.0.6"
 end