rbl 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2f79f3d05ec02a277eb9cc2b52e66cfb0bc167df
-  data.tar.gz: a1e2bd7b861f7bddd40b47092e508d542b78a89a
+  metadata.gz: 7e9f93f61446acfe3a434444b82dd743f9a1b4fc
+  data.tar.gz: f3d8e18c04933b302bfc2a54950f09b474815bf8
 SHA512:
-  metadata.gz: e5517a472833aad9bd8670c0aceb5b7fac368bf5cc0c96a12d1eed9352d563bd6599fcdceb006e4d6565567dfc1bd1a761ed395758b5448b3285b28e7b82aa51
-  data.tar.gz: ca25909f9d314a751ce37b51c5b82ca61e9cb26706bc68d60dddf7af896d8fb0c09ff3c2cbf07301397eae7cd1239024929c526b5a30225ff4b3a5b31b9ae6b3
+  metadata.gz: c8601be4ccdfc976d27a12a75b1215b2ea906b46418e6dfd4a85f281f37a5c7b367f076920e215d9b584900d75651b34fa7b6ee96668c84d8f60c68053faa876
+  data.tar.gz: 37c7beccfaae69fd0711941a2d0b274475df20ae8f1f3b36ae90f9910c62ca3cd0f60ca17930e17590a77dbe04afc3c3c93a521d9d12a4284ad765bf4594a7c7

data/README.md

@@ -29,8 +29,9 @@ I think I was right. Check it out, everyone -- you can write your Ruby scripts i
 * Fire up a REPL or run it in a script.
 * Immutable linked lists, vectors, and hashes courtesy of the [Hamster][hamster]
   library.
-* _(TODO)_ Macros, Clojure-style.
-* _(TODO)_ Namespaces, Clojure-style.
+* Clojure-style atoms, courtesy of [concurrent-ruby][concurrent].
+* _(TODO)_ Clojure-style macros.
+* _(TODO)_ Clojure-style namespaces.
 * _(TODO)_ Dependency management / the ability to use some sort of build tool to
   include Ruby libraries and use them via inter-op.
 
@@ -158,18 +159,18 @@ user> (:species barbara)
 But that's not all -- you can also use keywords to get the value of an instance variable:
 
 ```clojure
-; FIXME: This is a contrived example because it is not yet possible to easily
-define a class in RubyLisp.
+;; FIXME: This is a contrived example because it is not yet possible to easily
+;; define a class in RubyLisp.
 
-; rbl.core/=@ is provided as a convenient way to set instance variables on any
-object... even a string!
+;; rbl.core/=@ is provided as a convenient way to set instance variables on any
+;; object... even a string!
 user> (def s "my string")
 "my string"
 
 user> (=@ s :object_level 9001)
 9001
 
-; instance variables can then be retrieved by using a keyword as a function
+;; instance variables can then be retrieved by using a keyword as a function
 user> (:object_level s)
 9001
 ```
@@ -271,3 +272,4 @@ The gem is available as open source under the terms of the [MIT License](http://
 [ruby]: http://ruby-lang.org
 [mal]: https://github.com/kanaka/mal
 [hamster]: https://github.com/hamstergem/hamster
+[concurrent]: https://github.com/ruby-concurrency/concurrent-ruby

data/bin/rbl

@@ -13,13 +13,13 @@ USAGE = <<~HEREDOC
     #{File.basename $0} <filename>
 HEREDOC
 
-case ARGV.length
-when 0
+if ARGV.empty?
   RubyLisp::REPL::start
-when 1
+elsif ARGV[0] == '--help'
+  puts USAGE
+else
   file_contents = File.read ARGV[0]
+  ARGV.shift
   input = file_contents.gsub(/\A#!.*\n/, '')
   puts RubyLisp::Parser.parse(input)
-else
-  puts USAGE
 end

data/lib/rubylisp/environment.rb

@@ -2,14 +2,28 @@ require 'rubylisp/parser'
 
 module RubyLisp
   class Environment
-    attr_accessor :namespace, :vars, :outer
+    attr_accessor :namespace, :vars, :outer, :is_namespace, :out_env
 
-    def initialize(outer: nil, namespace: nil)
+    def initialize(outer: nil, namespace: nil, is_namespace: false, out_env: nil)
       @vars = {'*ns*' => (outer or self)}
       @outer = outer
       @namespace = namespace or
                    (outer.namespace if outer) or
                    "__ns_#{rand 10000}"
+      @is_namespace = is_namespace
+      @out_env = if out_env
+                   out_env
+                 else
+                   find_namespace
+                 end
+    end
+
+    def find_namespace
+      env = self
+      while !env.is_namespace && !env.outer.nil?
+        env = env.outer
+      end
+      env
     end
 
     def set key, val
@@ -31,7 +45,7 @@ module RubyLisp
       if env
         env.vars[key]
       else
-        raise RubyLisp::RuntimeError, "Unable to resolve symbol: #{key}"
+        raise RuntimeError, "Unable to resolve symbol: #{key}"
       end
     end
 
@@ -55,8 +69,8 @@ module RubyLisp
       root = File.expand_path '../..', File.dirname(__FILE__)
       input = File.read "#{root}/#{path}"
 
-      namespace = RubyLisp::Environment.new
-      RubyLisp::Parser.parse input, namespace
+      namespace = Environment.new
+      Parser.parse input, namespace
       namespace
     end
 

data/lib/rubylisp/evaluator.rb

@@ -1,226 +1,257 @@
 require 'rubylisp/environment'
 require 'rubylisp/printer'
 require 'rubylisp/types'
+require 'rubylisp/util'
+
+include RubyLisp::Util
 
 module RubyLisp
   module Evaluator
     module_function
 
-    def assert_number_of_args sexp, num_args
-      fn, *args = sexp.value
-      fn_name = fn.value
-      unless args.count == num_args
-        raise RubyLisp::RuntimeError,
-              "Wrong number of arguments passed to `#{fn_name}`; " +
-              "got #{args.count}, expected #{num_args}."
-      end
+    def macro_call? ast, env
+      return false unless ast.is_a? Hamster::List
+      symbol = ast[0]
+      return false unless symbol.class == Symbol
+      return false unless env.find(symbol.value)
+      value = symbol.resolve(env)
+      value.class == Function && value.is_macro
     end
 
-    def assert_at_least_n_args sexp, num_args
-      fn, *args = sexp.value
-      fn_name = fn.value
-      unless args.count >= num_args
-        raise RubyLisp::RuntimeError,
-              "Wrong number of arguments passed to `#{fn_name}`; " +
-              "got #{args.count}, expected at least #{num_args}."
+    def macroexpand input, env
+      while macro_call? input, env
+        macro = input[0].resolve(env)
+        input = macro.call(*input[1..-1])
       end
+      input
     end
 
-    def assert_arg_type sexp, arg_number, arg_type
-      fn = sexp.value[0]
-      fn_name = fn.value
-      arg = if arg_number == 'last'
-              sexp.value.last
-            else
-              sexp.value[arg_number]
-            end
+    def pair? form
+      sequential?(form) && form.count > 0
+    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 RubyLisp::RuntimeError,
-              "#{arg_description} to `#{fn_name}` must be a " +
-              "#{expected}; got a #{arg.class}."
+    def quasiquote ast
+      if !pair?(ast)
+        list [Symbol.new('quote'), ast]
+      elsif vector? ast
+        list [Symbol.new('vec'), quasiquote(ast.to_list)]
+      else
+        elem_a, *elems = ast
+
+        if elem_a.class == Symbol && elem_a.value == 'unquote'
+          elems[0]
+        elsif pair?(elem_a) &&
+              elem_a[0].class == Symbol &&
+              elem_a[0].value == 'splice-unquote'
+          list [Symbol.new('concat'), elem_a[1], quasiquote(elems)]
+        else
+          list [Symbol.new('cons'),
+                quasiquote(elem_a),
+                quasiquote(elems.to_list)]
+        end
       end
     end
 
+    def special_form? input, name
+      input[0].class == Symbol && input[0].value == name
+    end
+
     def eval_ast input, env
-      case input
-      when Array # of ASTs to be evaluated, e.g. multiple expressions in a file
-        input.compact.map {|form| eval_ast(form, env)}.last
-      when RubyLisp::HashMap
-        input.value.map {|k, v| [eval_ast(k, env), eval_ast(v, env)]}
-      when RubyLisp::List
-        if input.value.empty?
-          input.value
-        elsif input.value[0].value == 'apply'
-          coll = eval_ast(input.value[-1], env) || Hamster::Vector[]
-
-          # evaluate the last argument
-          sexp = RubyLisp::List.new(input.value.fill(coll, -1, 1))
-          # assert that it's enumerable
-          assert_arg_type sexp, 'last', Enumerable
-
-          # drop `apply` and pull the last form's contents into the sexp as
-          # multiple arguments
-          all_but_last_arg = sexp.value[1..-2].map {|arg| eval_ast arg, env}
-          fn, *args = all_but_last_arg + coll.to_list
-          sexp = RubyLisp::List.new([RubyLisp::Symbol.new("apply"), fn])
-          assert_arg_type sexp, 1, Proc
-          fn.call(*args)
-        elsif input.value[0].value == 'def'
-          assert_arg_type input, 1, RubyLisp::Symbol
-          key, val = input.value[1..-1]
-          env.set key.value, eval_ast(val, env)
-        elsif input.value[0].value == 'do'
-          body = input.value[1..-1]
-          body.map {|form| eval_ast(form, env)}.last
-        elsif input.value[0].value == 'fn'
-          if input.value[1].class == RubyLisp::Symbol
-            fn_name = input.value[1].value
-            bindings, *body = input.value[2..-1]
-          else
-            fn_name = "__fn_#{rand 10000}"
-            bindings, *body = input.value[1..-1]
-          end
+      # loop forever until a value is returned;
+      # this is for tail call optimization
+      while true
+        # (no-op if this is not a macro call)
+        input = macroexpand(input, env)
 
-          unless bindings.class == RubyLisp::Vector
-            raise RubyLisp::RuntimeError,
-                  "The bindings of `fn` must be a RubyLisp::Vector."
-          end
+        case input
+        when Array # of ASTs to be evaluated, e.g. multiple expressions in a file
+          # discard nils that can be produced by the reader, e.g. when a comment
+          # is read
+          input = input.compact
 
-          ampersand_indices = bindings.value.to_list.indices {|x| x.value == '&'}
-          if ampersand_indices.any? {|i| i != bindings.value.count - 2}
-            raise RubyLisp::RuntimeError,
-                  "An '&' can only occur right before the last binding."
-          end
+          # if input is empty (e.g. only comments), there is nothing to evaluate
+          return nil if input.empty?
+
+          # discard the return value of all but the last form
+          input[0..-2].each {|form| eval_ast(form, env)}
+          # recur; evaluate and return the value of the last form
+          input = input.last
+        when Hamster::Hash
+          return input.map {|k, v| [eval_ast(k, env), eval_ast(v, env)]}
+        when Hamster::List
+          if input.empty?
+            return input
+          elsif special_form? input, 'apply'
+            # evaluate the last argument
+            coll = eval_ast(input[-1], env) || vector()
+            # assert that it's enumerable
+            sexp = list input.fill(coll, -1, 1)
+            assert_arg_type sexp, 'last', Enumerable
+
+            # drop `apply` and pull the last form's contents into the sexp as
+            # multiple arguments
+            all_but_last_arg = sexp[1..-2].map {|arg| eval_ast arg, env}
+            fn, *args = all_but_last_arg + coll.to_list
+            sexp = list [Symbol.new("apply"), fn]
+            assert_arg_type sexp, 1, [Function, Proc]
+            return fn.call(*args)
+          # Provides a way to call a Ruby method that expects a block. Blocks
+          # are not first-class in Ruby, but they have similar semantics to
+          # functions.
+          #
+          # The last argument to call-with-block can be a Function or
+          # Proc that takes any number of arguments; it will be provided to the
+          # instance method as a block.
+          #
+          # ruby: instance.method(arg1, arg2, arg3) { do_something }
+          # rbl: (call-with-block .method instance [arg1 arg2 arg3] fn)
+          elsif special_form? input, 'call-with-block'
+            assert_number_of_args input, 4
 
-          fn = lambda do |*args|
-            inner_env = RubyLisp::Environment.new(outer: env)
-            inner_env.set(fn_name, fn) # self-referential lambda omg
+            assert_arg_type input, 1, Symbol
 
-            sexp = RubyLisp::List.new([RubyLisp::Symbol.new(fn_name), *args])
-            if bindings.value.any? {|binding| binding.value == '&'}
-              required_args = bindings.value.count - 2
-              assert_at_least_n_args sexp, required_args
+            sexp = input[2..-1].map {|form| eval_ast(form, env)}
+                               .cons(input[1].value[1..-1].to_sym)
+                               .cons(input[0])
 
-              bindings.value[0..-3].zip(args.take(required_args)).each do |k, v|
-                inner_env.set(k.value, v)
-              end
+            assert_arg_type sexp, 3, [Hamster::List, Hamster::Vector]
+            assert_arg_type sexp, 4, [Function, Proc]
 
-              rest_args = if args.count > required_args
-                            args[required_args..-1].to_list
-                          else
-                            nil
-                          end
+            method, receiver, method_args, fn = sexp[1..-1]
 
-              inner_env.set(bindings.value[-1].value, rest_args)
+            return receiver.send(method, *method_args) do |*block_args|
+              fn.call(*block_args)
+            end
+          elsif special_form? input, 'def'
+            assert_arg_type input, 1, Symbol
+            k, v = input[1..-1]
+            key, val = [k.value, eval_ast(v, env)]
+            return env.out_env.set key, val
+          elsif special_form? input, 'defmacro*'
+            assert_arg_type input, 1, Symbol
+            key, val = input[1..-1]
+            macro = eval_ast(val, env)
+            macro.is_macro = true
+            return env.set key.value, macro
+          elsif special_form? input, 'do'
+            body = input[1..-1]
+            # discard the return values of all but the last form
+            body[0..-2].each {|form| eval_ast(form, env)}
+            # recur; evaluate and return the last form
+            input = body.last
+          elsif special_form? input, 'eval'
+            assert_number_of_args input, 1
+
+            form = eval_ast(input[1], env)
+            input = form
+          elsif special_form? input, 'fn'
+            if input[1].class == Symbol
+              fn_name = input[1].value
+              more = input[2..-1]
             else
-              required_args = bindings.value.count
-              assert_number_of_args sexp, required_args
+              fn_name = "__fn_#{rand 10000}"
+              more = input[1..-1]
+            end
 
-              bindings.value.zip(args).each do |k, v|
-                inner_env.set(k.value, v)
-              end
+            arities = more[0].class == Hamster::Vector ? [list(more)] : more
+
+            return fn = Function.new(fn_name, env, arities) {|*fn_args|
+              arity = fn.get_arity(fn_args)
+              eval_ast arity.body, fn.gen_env(arity, fn_args, env)
+            }
+          elsif special_form? input, 'if'
+            unless input[1..-1].count > 1
+              raise RuntimeError,
+                    "An `if` form must at least have a 'then' branch."
             end
 
-            body.map {|form| eval_ast(form, inner_env)}.last
-          end
-        elsif input.value[0].value == 'if'
-          cond, then_form, else_form = input.value[1..-1]
-          unless then_form
-            raise RubyLisp::RuntimeError,
-                  "An `if` form must at least have a 'then' branch."
-          end
+            cond, then_form, else_form = input[1..-1]
 
-          if (eval_ast cond, env)
-            eval_ast(then_form, env)
-          elsif else_form
-            eval_ast(else_form, env)
-          end
-        elsif input.value[0].value == 'in-ns'
-          assert_number_of_args input, 1
-          input.value[1] = eval_ast(input.value[1], env)
-          assert_arg_type input, 1, RubyLisp::Symbol
-          ns_name = input.value[1].to_s
-          # TODO: register ns and switch to it
-          env.namespace = ns_name
-        elsif input.value[0].value == 'let'
-          assert_arg_type input, 1, RubyLisp::Vector
-          inner_env = RubyLisp::Environment.new(outer: env)
-          bindings, *body = input.value[1..-1]
-          unless bindings.value.count.even?
-            raise RubyLisp::RuntimeError,
-                  "The bindings vector of `let` must contain an even number " +
-                  " of forms."
-          end
+            if (eval_ast cond, env)
+              input = then_form
+            elsif else_form
+              input = else_form
+            else
+              return nil
+            end
+          elsif special_form? input, 'in-ns'
+            assert_number_of_args input, 1
+            input[1] = eval_ast(input[1], env)
+            assert_arg_type input, 1, Symbol
+            ns_name = input[1].to_s
+            # TODO: register ns and switch to it
+            env.is_namespace = true
+            return env.namespace = ns_name
+          elsif special_form? input, 'let'
+            assert_arg_type input, 1, Hamster::Vector
+            inner_env = Environment.new(outer: env)
+            bindings, *body = input[1..-1]
+            unless bindings.count.even?
+              raise RuntimeError,
+                    "The bindings vector of `let` must contain an even number " +
+                    " of forms."
+            end
 
-          bindings.value.each_slice(2) do |(k, v)|
-            inner_env.set k.value, eval_ast(v, inner_env)
-          end
+            bindings.each_slice(2) do |(binding, value)|
+              inner_env.set binding.value, eval_ast(value, inner_env)
+            end
 
-          body.map {|form| eval_ast(form, inner_env)}.last
-        elsif input.value[0].value == 'ns'
-          # ns will be defined more robustly in rbl.core, but rbl.core also
-          # needs the `ns` form in order to declare that it is rbl.core.
-          #
-          # defining it here in a minimal form where it is equivalent to in-ns,
-          # except that you don't have to quote the namespace name
-          assert_number_of_args input, 1
-          assert_arg_type input, 1, RubyLisp::Symbol
-          ns_name = input.value[1].to_s
-          # TODO: register ns and switch to it
-          env.namespace = ns_name
-        elsif input.value[0].value == 'quote'
-          assert_number_of_args input, 1
-          fn, *args = input.value
-          quoted_form = args[0]
-
-          if [RubyLisp::HashMap, RubyLisp::List, RubyLisp::Vector].member? quoted_form.class
-            quoted_form.quote.value
+            # discard the return values of all but the last form
+            body[0..-2].each {|expr| eval_ast(expr, inner_env)}
+            # recur; evaluate and return the last form's value
+            env = inner_env
+            input = body.last
+          elsif special_form? input, 'macroexpand'
+            assert_number_of_args input, 1
+            form = eval_ast(input[1], env)
+            return macroexpand(form, env)
+          elsif special_form? input, 'ns'
+            # ns will be defined more robustly in rbl.core, but rbl.core also
+            # needs the `ns` form in order to declare that it is rbl.core.
+            #
+            # defining it here in a minimal form where it is equivalent to in-ns,
+            # except that you don't have to quote the namespace name
+            assert_number_of_args input, 1
+            assert_arg_type input, 1, Symbol
+            ns_name = input[1].to_s
+            # TODO: register ns and switch to it
+            env.is_namespace = true
+            return env.namespace = ns_name
+          elsif special_form? input, 'quasiquote'
+            assert_number_of_args input, 1
+            ast = input[1]
+            input = quasiquote(ast)
+          elsif special_form? input, 'quote'
+            assert_number_of_args input, 1
+            return input[1]
+          elsif special_form? input, 'resolve'
+            assert_number_of_args input, 1
+            symbol = eval_ast(input[1], env)
+            sexp = list input.fill(symbol, 1, 1)
+            assert_arg_type sexp, 1, Symbol
+            return symbol.resolve(env)
           else
-            quoted_form.quote
+            fn, *args = input.map {|value| eval_ast(value, env)}
+            if fn.class == Function
+              # recur with input and env set to the body of the function and an
+              # inner environment where the function's bindings are set to the
+              # values of the arguments
+              arity = fn.get_arity(args)
+              env = fn.gen_env(arity, args, env)
+              input = arity.body
+            else
+              return fn.call(*args)
+            end
           end
-        elsif input.value[0].value == 'resolve'
-          assert_number_of_args input, 1
-          symbol = eval_ast(input.value[1], env)
-          sexp = RubyLisp::List.new(input.value.fill(symbol, 1, 1))
-          assert_arg_type sexp, 1, RubyLisp::Symbol
-          symbol.resolve(env)
-        else
-          fn, *args = input.value.map {|value| eval_ast(value, env)}
-          fn.call(*args)
-        end
-      when RubyLisp::Symbol
-        if input.quoted
-          input
+        when Hamster::Vector
+          return input.map {|value| eval_ast(value, env)}
+        when Symbol
+          return input.resolve(env)
+        when Value
+          return input.value
         else
-          input.resolve(env)
+          return input
         end
-      when RubyLisp::Vector
-        input.value.map {|value| eval_ast(value, env)}
-      else
-        input.value
       end
     end
   end