bus-scheme 0.7.1 → 0.7.5

data/Manifest.txt

@@ -5,13 +5,17 @@ Rakefile
 bin/bus
 lib/array_extensions.rb
 lib/bus_scheme.rb
+lib/cons.rb
 lib/eval.rb
 lib/lambda.rb
-lib/definitions.rb
 lib/object_extensions.rb
 lib/parser.rb
+lib/primitives.rb
+lib/scheme/core.scm
 test/foo.scm
+test/test_core.rb
 test/test_eval.rb
 test/test_helper.rb
 test/test_lambda.rb
 test/test_parser.rb
+test/test_primitives.rb

data/README.txt

@@ -1,5 +1,5 @@
 Bus Scheme
-    by Phil Hagelberg (c) 2007
+    by Phil Hagelberg (c) 2007 - 2008
     http://bus-scheme.rubyforge.org
 
 == Description
@@ -39,18 +39,27 @@ $ bus foo.scm # load a file
 
 Bus Scheme is currently missing pieces of functionality:
 
-* move as many definitions into Scheme as possible
-* compile to Rubinius bytecode
-* optimize tail call recursion
-* continuations (?!?)
-* check for memory leaks
-* parse cons cells
-* parse character literals
-* parse quote, unquote
+=== Parser
+ * parse character literals
+ ** alternate define lambda forms
+ ** parse dotted cons cells
+ *** look up and enforce rules for identifier names
+
+=== General
+ * lambda args should get passed in as lists by default, not vectors/arrays
+ * (lambda args body) for rest args
+ * stack traces on error plz
+ ** optimize tail call recursion
+ ** some kind of load path?
 
 Failing tests for some of these are already included (commented out,
 mostly) in the relevant test files.
 
+=== Long Term (post 1.0)
+ * continuations (?!?)
+ * compile to Rubinius bytecode
+ * parse rationals, scientific, complex, and polar complex numbers
+
 == Requirements
 
 Bus Scheme should run on (at least) Ruby 1.8, Ruby 1.9, and Rubinius.

data/Rakefile

@@ -15,11 +15,25 @@ Hoe.new('bus-scheme', BusScheme::VERSION) do |p|
   p.remote_rdoc_dir = ''
 end
 
+desc "Code statistics"
 task :stats do
   require 'code_statistics'
   CodeStatistics.new(['lib'], ['Unit tests', 'test']).to_s
 end
 
+desc "Complexity statistics"
 task :flog do
   system "flog lib/*rb"
 end
+
+desc "Show todo items"
+task :todo do
+  puts File.read('README.txt').match(/== Todo(.*)== Requirements/m)[1].split("\n").grep(/^( \*|===)/).join("\n")
+end
+
+desc "Show tests that have been commented out"
+task :commented_tests do
+  Dir.glob('test/test_*.rb').each do |file|
+    puts File.read(file).grep(/^\s*#\s*def (test_[^ ]*)/)
+  end
+end

data/lib/array_extensions.rb

@@ -6,6 +6,16 @@ class Array
 
   alias_method :car, :first
   alias_method :cdr, :rest
+
+  def to_list
+    if self.cdr.empty?
+      BusScheme::Cons.new(self.car, nil)
+    else
+      BusScheme::Cons.new(self.car, self.cdr.to_list)
+    end
+  end
+
+  alias_method :to_sexp, :to_list
 end
 
 module Enumerable # for 1.9, zip is defined on Enumerable

data/lib/bus_scheme.rb

@@ -11,32 +11,16 @@ require 'object_extensions'
 require 'array_extensions'
 require 'parser'
 require 'eval'
-require 'definitions'
+require 'primitives'
+require 'cons'
 require 'lambda'
 
 module BusScheme
-  VERSION = "0.7.1"
+  VERSION = "0.7.5"
 
   SYMBOL_TABLE = {}.merge(PRIMITIVES).merge(SPECIAL_FORMS)
   PROMPT = '> '
 
-  # what scope is appropraite for this symbol
-  def self.scope_of(symbol)
-    [Lambda.scope, SYMBOL_TABLE].compact.detect { |scope| scope.has_key?(symbol) }
-  end
-  
-  # symbol lookup
-  def self.[](symbol)
-    scope = scope_of(symbol)
-    raise EvalError.new("Undefined symbol: #{symbol}") unless scope
-    scope && scope[symbol]
-  end
-
-  # symbol assignment to value
-  def self.[]=(symbol, value)
-    (scope_of(symbol) || Lambda.scope || SYMBOL_TABLE)[symbol] = value
-  end
-
   # symbol special form predicate
   def self.special_form?(symbol)
     SPECIAL_FORMS.has_key?(symbol)
@@ -46,7 +30,9 @@ module BusScheme
   def self.repl
     loop do
       puts begin
-             BusScheme.eval_string(Readline.readline(PROMPT))
+             input = Readline.readline(PROMPT)
+             exit if input.nil? # only Ctrl-D produces nil here it seems
+             BusScheme.eval_string input
            rescue Interrupt
              'Type "(quit)" to leave Bus Scheme.'
            rescue BusSchemeError => e
@@ -57,4 +43,6 @@ module BusScheme
            end
     end
   end
+
+  ['core'].each { |file| SYMBOL_TABLE[:load].call("#{File.dirname(__FILE__)}/scheme/#{file}.scm") }
 end

data/lib/cons.rb

@@ -0,0 +1,41 @@
+module BusScheme
+  class Cons
+    attr_accessor :car, :cdr
+    
+    def initialize(car, cdr = nil)
+      @car, @cdr = [car, cdr]
+    end
+
+    def ==(other)
+      @car == other.car and @cdr == other.cdr
+    end
+
+    alias_method :first, :car
+    alias_method :rest, :cdr
+
+    def to_a
+      if @cdr.respond_to? :to_a
+        [@car] + @cdr.to_a
+      elsif !@cdr.nil?
+        [@car, @cdr]
+      else
+        [@car]
+      end
+    end
+
+    def inspect(open = '(', close = ')')
+      str = open + @car.inspect
+      if @cdr.nil?
+        str + close
+      elsif @cdr.is_a? Cons
+        str + ' ' + @cdr.inspect('', '') + close
+      else
+        str + ' . ' + @cdr.inspect + close
+      end
+    end
+  end
+
+  def cons(car, cdr = nil)
+    Cons.new(car, cdr)
+  end
+end

data/lib/eval.rb

@@ -7,12 +7,11 @@ module BusScheme
 
     # Eval a form passed in as an array
     def eval_form(form)
-      if form == []
-        nil
-      elsif form.is_a? Array
+      if form.is_a? Array or form.is_a? Cons and form.first
         apply(form.first, *form.rest)
       elsif form.is_a? Symbol
-        BusScheme[form]
+        raise EvalError.new("Undefined symbol: #{form}") unless Lambda.scope.has_key?(form)
+        Lambda.scope[form]
       else # well it must be a literal then
         form
       end

data/lib/lambda.rb

@@ -1,30 +1,34 @@
 module BusScheme
-  class Scope < Hash
-    def initialize(table, parent)
+  # The RecursiveHash is needed to store Lambda environments
+  class RecursiveHash < Hash
+    # takes a hash and a parent
+    def initialize(hash, parent)
       @parent = parent
-      table.each { |k, v| self[k] = v }
+      hash.each { |k, v| self[k] = v }
     end
 
-    alias_method :old_has_key?, :has_key?
+    alias_method :immediate_has_key?, :has_key?
+    alias_method :immediate_set, :[]=
+    alias_method :immediate_lookup, :[]
+
     def has_key?(symbol)
-      old_has_key?(symbol) or @parent && @parent.has_key?(symbol)
+      immediate_has_key?(symbol) or @parent && @parent.has_key?(symbol)
     end
 
-    alias_method :lookup, :[]
     def [](symbol)
-      lookup(symbol) or @parent && @parent[symbol]
+      immediate_lookup(symbol) or @parent && @parent[symbol]
     end
 
-    alias_method :old_set, :[]=
     def []=(symbol, value)
-      if !old_has_key?(symbol) and @parent and @parent.has_key?(symbol)
+      if !immediate_has_key?(symbol) and @parent and @parent.has_key?(symbol)
         @parent[symbol] = value
       else
-        old_set symbol, value
+        immediate_set symbol, value
       end
     end
   end
 
+  # Lambdas are closures.
   class Lambda
     @@stack = []
 
@@ -38,13 +42,14 @@ module BusScheme
     # execute lambda with given arg_values
     def call(*arg_values)
       raise BusScheme::ArgumentError if @arg_names.length != arg_values.length
-      @scope = Scope.new(@arg_names.zip(arg_values).to_hash, @enclosing_scope)
+      @scope = RecursiveHash.new(@arg_names.zip(arg_values).to_hash, @enclosing_scope)
       @@stack << self
-      BusScheme[:begin].call(*@body).affect { @@stack.pop }
+      BusScheme.eval_form(@body.unshift(:begin)).affect { @@stack.pop }
     end
 
+    # What's the current scope?
     def self.scope
-      @@stack.empty? ? nil : @@stack.last.scope
+      @@stack.empty? ? SYMBOL_TABLE : @@stack.last.scope
     end
   end
 end

data/lib/object_extensions.rb

@@ -5,4 +5,8 @@ class Object
     yield self
     return self
   end
+
+  def to_sexp
+    self
+  end
 end

data/lib/parser.rb

@@ -2,7 +2,7 @@ module BusScheme
   class << self
     # Turn an input string into an S-expression
     def parse(input)
-      parse_tokens tokenize(normalize_whitespace(input))
+      parse_tokens tokenize(input).flatten
     end
 
     # Turn a list of tokens into a properly-nested S-expression
@@ -40,30 +40,38 @@ module BusScheme
 
     # Take a token off the input string and return it
     def pop_token(input)
+      # can't use ^ since it matches line beginnings in mid-string
       token = case input
-              when /^ +/ # whitespace
-                input[0 ... 1] = ''
+              when /\A(\s|;.*$)/ # ignore whitespace and comments
+                input[0 .. Regexp.last_match[1].length - 1] = ''
                 return pop_token(input)
-              when /^\(/ # open paren
-                :'('
-              when /^\)/ # closing paren
-                :')'
-              when /^(\d+)/ # positive integer
+              when /\A(\(|\))/ # parens
+                Regexp.last_match[1].intern
+              when /\A#\(/ # vector
+                input[0 ... 2] = ''
+                return [:'(', :vector, tokenize(input)]
+              when /\A'/ # single-quote
+                input[0 ... 1] = ''
+                return [:'(', :quote,
+                        if input[0 ... 1] == '('
+                          tokenize(input)
+                        else
+                          pop_token(input)
+                        end,
+                        :')']
+              when /\A(-?[0-9]*\.[0-9]+)/ # float
+                Regexp.last_match[1].to_f
+              when /\A(-?[0-9]+)/ # integer
                 Regexp.last_match[1].to_i
-              when /^"(.*?)"/ # string
-                Regexp.last_match[1]
-              when /^([^ \)]+)/ # symbol
+              when /\A("(.*?)")/ # string
+                Regexp.last_match[2]
+              when /\A([^ \n\)]+)/ # symbol
                 Regexp.last_match[1].intern
               end
-      # compensate for quotation marks
-      length = token.is_a?(String) ? token.length + 2 : token.to_s.length
-      input[0 .. length - 1] = ''
-      return token
-    end
 
-    # Treat all whitespace in a string as spaces
-    def normalize_whitespace(string)
-      string && string.gsub(/\t/, ' ').gsub(/\n/, ' ').gsub(/ +/, ' ')
+      # Remove the matched part from the string
+      input[0 .. Regexp.last_match[1].length - 1] = '' if token
+      return token
     end
   end
 end

data/lib/primitives.rb

@@ -0,0 +1,45 @@
+module BusScheme
+  class BusSchemeError < StandardError; end
+  class ParseError < BusSchemeError; end
+  class EvalError < BusSchemeError; end
+  class ArgumentError < BusSchemeError; end
+
+  PRIMITIVES = {
+    # right now I believe there are as few things implemented primitively as possible
+    # except for functions that require splat args. do we need something like &rest?
+    
+    '#t'.intern => true, # :'#t' screws up emacs' ruby parser
+    '#f'.intern => false,
+
+    :+ => lambda { |*args| args.inject { |sum, i| sum + i } },
+    :- => lambda { |x, y| x - y },
+    :* => lambda { |*args| args.inject { |product, i| product * i } },
+    '/'.intern => lambda { |x, y| x / y },
+
+    :concat => lambda { |*args| args.join('') },
+    :cons => lambda { |car, cdr| Cons.new(car, cdr) },
+    # todo: lambda args should come as lists by default, not vectors/arrays
+    :list => lambda { |*members| members.to_list },
+    :vector => lambda { |*members| members },
+    
+    :ruby => lambda { |*code| eval(code.join('')) },
+    :eval => lambda { |code| eval_form(code) },
+    :send => lambda { |obj, *message| obj.send(*message) },
+    :load => lambda { |filename| eval_string("(begin #{File.read(filename)} )") },
+    :exit => lambda { exit }, :quit => lambda { exit },
+  }
+
+  # if we add in macros, can some of these be defined in scheme?
+  SPECIAL_FORMS = {
+    :quote => lambda { |arg| arg.to_sexp },
+    :if => lambda { |q, yes, *no| eval_form(q) ? eval_form(yes) : eval_form([:begin] + no) },
+    :begin => lambda { |*args| args.map{ |arg| eval_form(arg) }.last },
+    :set! => lambda { |sym, value| raise EvalError.new unless Lambda.scope.has_key?(sym) and 
+      Lambda.scope[sym] = eval_form(value); sym },
+    :lambda => lambda { |args, *form| Lambda.new(args, form) },
+    :define => lambda { |sym, definition| Lambda.scope[sym] = eval_form(definition); sym },
+
+    # once we have macros, this can be defined in scheme
+    :let => lambda { |defs, *body| Lambda.new(defs.map{ |d| d.car }, body).call(*defs.map{ |d| eval_form d.last }) }
+  }
+end

data/lib/scheme/core.scm

@@ -0,0 +1,35 @@
+(define intern
+  (lambda (sym) (send sym (quote intern))))
+
+(define substring
+  (lambda (string to from) (send string (quote []) to from)))
+
+(define null?
+  (lambda (expr) (= expr ())))
+
+(define >
+  (lambda (x y) (send x (intern ">") y)))
+
+(define <
+  (lambda (x y) (send x (intern "<") y)))
+
+(define =
+  (lambda (x y) (send x (intern "==") y)))
+
+(define and
+  (lambda (x y) (if x (if y y #f) #f)))
+
+(define or
+  (lambda (x y) (if x x (if y y #f))))
+
+(define not
+  (lambda (expr) (if expr #f #t)))
+
+(define car
+  (lambda (lst) (send lst (quote first))))
+
+(define cdr
+  (lambda (lst) (send lst (quote rest))))
+
+(define cadr
+  (lambda (lst) (car (cdr lst))))

data/test/test_core.rb

@@ -0,0 +1,43 @@
+$LOAD_PATH << File.dirname(__FILE__)
+require 'test_helper'
+
+class CoreTest < Test::Unit::TestCase
+  def test_comparison
+    assert_evals_to true, "(null? ())"
+    assert_evals_to false, "(null? 43)"
+    assert_evals_to true, "(> 4 2)"
+    assert_evals_to false, "(> 9 13)"
+    assert_evals_to true, "(= 4 4)"
+    assert_evals_to false, "(= (+ 2 2) 5)"
+    assert_evals_to true, "(not #f)"
+    assert_evals_to false, "(not #t)"
+  end
+
+  def test_string_functions
+    assert_evals_to :hi, [:intern, 'hi']
+    assert_evals_to 'lo', [:substring, 'hello', 3, 5]
+  end
+
+  def test_list_functions
+    assert_evals_to :foo, "(car (cons (quote foo) (quote bar)))"
+    assert_evals_to :bar, "(cdr (cons (quote foo) (quote bar)))"
+    assert_equal(BusScheme::Cons.new(:foo, BusScheme::Cons.new(:bar, nil)),
+                 [:foo, :bar].to_list)
+    assert_evals_to(BusScheme::Cons.new(2, BusScheme::Cons.new(3, nil)),
+                    "(list 2 3)")
+    assert_evals_to "bar", "(cadr (list \"foo\" \"bar\")"
+    assert_evals_to [1, :foo].to_list, "(list 1 'foo)"
+  end
+
+  def test_boolean_logic
+    assert_evals_to true, "(and #t #t)"
+    assert_evals_to false, "(and #t #f)"
+    assert_evals_to false, "(and #f #t)"
+    assert_evals_to false, "(and #f #f)"
+
+    assert_evals_to true, "(or #t #t)"
+    assert_evals_to true, "(or #t #f)"
+    assert_evals_to true, "(or #f #t)"
+    assert_evals_to false, "(or #f #f)"
+  end
+end

data/test/test_eval.rb

@@ -3,7 +3,8 @@ require 'test_helper'
 
 class BusSchemeEvalTest < Test::Unit::TestCase
   def test_eval_empty_list
-    assert_evals_to nil, []
+    assert_evals_to [], []
+    assert_evals_to true, "(if () #t #f)"
   end
 
   def test_eval_number
@@ -11,12 +12,12 @@ class BusSchemeEvalTest < Test::Unit::TestCase
   end
 
   def test_set_symbol
-    BusScheme[:hi] = 'hi'
-    assert BusScheme::SYMBOL_TABLE[:hi]
+    BusScheme::Lambda.scope[:hi] = 'hi'
+    assert BusScheme::Lambda.scope[:hi]
   end
   
   def test_eval_symbol
-    eval "(define hi 13)"
+    BusScheme::Lambda.scope[:hi] = 13
     assert_evals_to 13, :hi
   end
 
@@ -28,49 +29,6 @@ class BusSchemeEvalTest < Test::Unit::TestCase
     assert_evals_to 2, [:+, 1, 1]
   end
 
-  def test_many_args_for_arithmetic
-    assert_evals_to 4, [:+, 1, 1, 1, 1]
-    assert_evals_to 2, [:*, 1, 2, 1, 1]
-  end
-
-  def test_arithmetic
-    assert_evals_to 2, [:'-', 4, 2]
-    assert_evals_to 2, [:'/', 4, 2]
-    assert_evals_to 2, [:'*', 1, 2]
-  end
-
-  def test_define
-    clear_symbols :foo
-    eval("(define foo 5)")
-    assert_equal 5, BusScheme[:foo]
-    eval("(define foo (quote (5 5 5))")
-    assert_evals_to [5, 5, 5], :foo
-  end
-
-  def test_define_returns_defined_term
-    assert_evals_to :foo, "(define foo 2)"
-    assert_equal 2, eval("foo")
-  end
-
-  def test_string_primitives
-    assert_evals_to :hi, [:intern, 'hi']
-    assert_evals_to 'lo', [:substring, 'hello', 3, -1]
-  end
-
-  def test_booleans
-    assert BusScheme::PRIMITIVES.has_key? '#f'.intern
-    assert_evals_to false, '#f'
-    assert_evals_to true, '#t'
-  end
-
-  def test_eval_quote
-    assert_evals_to [:'+', 2, 2], [:quote, [:'+', 2, 2]]
-  end
-
-  def test_quote
-    assert_evals_to :hi, [:quote, :hi]
-  end
-
   def test_nested_arithmetic
     assert_evals_to 6, [:+, 1, [:+, 1, [:*, 2, 2]]]
   end
@@ -85,33 +43,8 @@ class BusSchemeEvalTest < Test::Unit::TestCase
     assert_evals_to 21, [:*, 3, :foo]
   end
 
-  def test_if
-    assert_evals_to 7, [:if, '#f'.intern, 3, 7]
-    assert_evals_to 3, [:if, [:>, 8, 2], 3, 7]
-  end
-
-  def test_begin
-    eval([:begin,
-          [:define, :foo, 779],
-          9])
-    assert_equal 779, BusScheme[:foo]
-  end
-
-  def test_set!
-    clear_symbols(:foo)
-    # can only set! existing variables
-    assert_raises(BusScheme::EvalError) { eval "(set! foo 7)" }
-    eval "(define foo 3)"
-    eval "(set! foo 7)"
-    assert_evals_to 7, :foo
-  end
-
-  def test_load_file
-    eval "(load \"#{File.dirname(__FILE__)}/foo.scm\")"
-    assert_evals_to 3, :foo
-  end
-
-  def test_eval_ruby
-    assert_evals_to "foofoofoo", "(ruby \"'foo' * 3\")"
+  def test_single_quote
+    assert_evals_to :foo, "'foo"
+    assert_evals_to [:foo, :biz, :bbb].to_list, "'(foo biz bbb)"
   end
 end

data/test/test_helper.rb

@@ -1,10 +1,3 @@
-begin
-  require 'rubygems'
-  gem 'miniunit'
-rescue LoadError
-  puts "Proceeding with standard test/unit instead of miniunit."
-end
-
 $LOAD_PATH << File.dirname(__FILE__) + '/../lib/'
 require 'test/unit'
 require 'bus_scheme'

data/test/test_lambda.rb

@@ -13,7 +13,7 @@ class BusSchemeLambdaTest < Test::Unit::TestCase
     assert_equal [], l.arg_names
 
     eval("(define foo (lambda () (+ 1 1)))")
-    assert BusScheme[:foo].is_a?(BusScheme::Lambda)
+    assert BusScheme::Lambda.scope[:foo].is_a?(BusScheme::Lambda)
     assert_evals_to 2, [:foo]
   end
 
@@ -34,9 +34,9 @@ class BusSchemeLambdaTest < Test::Unit::TestCase
   def test_lambda_args_dont_stay_in_scope
     clear_symbols(:x, :foo)
     eval("(define foo (lambda (x) (+ x 1)))")
-    assert_nil BusScheme.scope_of(:x)
+    assert_nil BusScheme::Lambda.scope[:x]
     assert_evals_to 2, [:foo, 1]
-    assert_nil BusScheme.scope_of(:x)
+    assert_nil BusScheme::Lambda.scope[:x]
   end
 
   def test_lambda_calls_lambda

data/test/test_parser.rb

@@ -63,39 +63,61 @@ class BusSchemeParserTest < Test::Unit::TestCase
   end
 
   def test_whitespace_indifferent
-    assert_parses_equal "(+ 2 2)", "(+ 2  \n \t    2)"
-  end
-
-  #   def test_parses_dotted_cons
-  #     assert_parses_to "(22 . 11)", [:cons, 22, 11]
-  #     assert_parses_to "((+ 2 2) . 11)", [:cons, [:+, 2, 2], 11]
-  #   end
-
-  #   def test_floats
-  #     assert_parses_to "44.9", 44.9
-  #     assert_parses_to "0.22", 0.22
-  #     assert_parses_to ".22", 0.22
-  #     assert_parses_to "2.220", 2.22
-  #   end
-
-  #   def test_negative_numbers
-  #     assert_parses_to "-1", -1
-  #     assert_parses_to "-0", 0
-  #     assert_parses_to "-02", -2
-  #   end
-
-  #   def test_negative_floats
-  #     assert_parses_to "-0.22", -0.22
-  #     assert_parses_to "-.22", -0.22
-  #     assert_parses_to "-0.10", -0.1
-  #   end
-
-  #   def test_character_literals
-  #     assert_parses_to "?e", "e"
-  #     assert_parses_to "?A", "A"
-  #     # what else?
-  #   end
+    assert_equal 3, BusScheme.pop_token("3 2\n2")
+    assert_parses_equal "(+ 2 2)", "(+ 2       2)", "confused by spaces"
+    assert_parses_equal "(+ 2 2)", "(+ 2  \t   2)", "confused by tab"
+    assert_parses_equal "(+ 2 2)", "(+ 2\n2)", "confused by newline"
+  end
+
+  def test_parses_vectors
+    assert_equal [:'(', :vector, 1, 2, :')'], BusScheme::tokenize("#(1 2)").flatten
+    assert_parses_to  "#(1 2)", [:vector, 1, 2]
+    assert_parses_to "#(1 (2 3 4)", [:vector, 1, [2, 3, 4]]
+  end
+  
+#   def test_parses_dotted_cons
+#     assert_parses_to "(22 . 11)", [:cons, 22, 11]
+#     assert_parses_to "((+ 2 2) . 11)", [:cons, [:+, 2, 2], 11]
+#   end
+
+  def test_floats
+    assert_parses_to "44.9", 44.9
+    assert_parses_to "0.22", 0.22
+    assert_parses_to ".22", 0.22
+    assert_parses_to "2.220", 2.22
+  end
+
+  def test_negative_ints
+    assert_parses_to "-1", -1
+    assert_parses_to "-0", 0
+    assert_parses_to "-02", -2
+  end
 
+  def test_negative_floats
+    assert_parses_to "-0.22", -0.22
+    assert_parses_to "-.22", -0.22
+    assert_parses_to "-0.10", -0.1
+  end
+
+#   def test_character_literals
+#     assert_parses_to "?#e", "e"
+#     assert_parses_to "?#A", "A"
+#   end
+  
+  def test_quote
+    assert_parses_to "'foo", [:quote, :foo]
+    assert_equal [:'(', :quote, :'(', :foo, :bar, :baz, :')', :')'], BusScheme::tokenize("'(foo bar baz)").flatten
+    assert_parses_to "'(foo bar baz)", [:quote, [:foo, :bar, :baz]]
+  end
+
+  #  have to change normalize_whitespace to not turn newlines into spaces for this to work
+  def test_ignore_comments
+    assert_parses_to ";; hello", nil
+    assert_parses_to "12 ;; comment", 12
+    assert_parses_to "(+ 2;; this is a mid-sexp comment
+2)", [:+, 2, 2]
+  end
+  
   def test_parse_random_elisp_form_from_my_dot_emacs
     lisp = "(let ((system-specific-config
          (concat \"~/.emacs.d/\"
@@ -108,7 +130,7 @@ class BusSchemeParserTest < Test::Unit::TestCase
                                [:'shell-command-to-string', "hostname"]]]],
                       [:if, [:'file-exists-p', :'system-specific-config'],
                        [:load, :'system-specific-config']]])
-  end
+   end
 
   private
 
@@ -116,7 +138,7 @@ class BusSchemeParserTest < Test::Unit::TestCase
     assert_equal expected, BusScheme.parse(actual_string)
   end
 
-  def assert_parses_equal(one, two)
-    assert_equal BusScheme.parse(one), BusScheme.parse(two)
+  def assert_parses_equal(one, two, message = nil)
+    assert_equal BusScheme.parse(one), BusScheme.parse(two), message
   end
 end

data/test/test_primitives.rb

@@ -0,0 +1,118 @@
+$LOAD_PATH << File.dirname(__FILE__)
+require 'test_helper'
+
+class PrimitivesTest < Test::Unit::TestCase
+  def test_booleans
+    assert BusScheme::PRIMITIVES.has_key? '#f'.intern
+    assert_evals_to false, '#f'
+    assert_evals_to true, '#t'
+  end
+
+  def test_arithmetic
+    assert_evals_to 2, [:'-', 4, 2]
+    assert_evals_to 2, [:'/', 4, 2]
+    assert_evals_to 2, [:'*', 1, 2]
+  end
+
+  def test_many_args_for_arithmetic
+    assert_evals_to 4, [:+, 1, 1, 1, 1]
+    assert_evals_to 2, [:*, 1, 2, 1, 1]
+  end
+
+  def test_concat
+    assert_evals_to "foobar", "(concat \"foo\" \"bar\")"
+  end
+
+  def test_eval
+    assert_evals_to 23, "(eval '(+ 20 3))"
+  end
+  
+  def test_eval_ruby
+    assert_evals_to "foofoofoo", "(ruby \"'foo' * 3\")"
+  end
+
+  def test_message_passing
+    assert_evals_to 7, "(send 3 (intern \"+\") 4)"
+  end
+
+  def test_load_file
+    eval "(load \"#{File.dirname(__FILE__)}/foo.scm\")"
+    assert_evals_to 3, :foo
+  end
+
+  # special forms
+  def test_define
+    clear_symbols :foo
+    eval("(define foo 5)")
+    assert_equal 5, BusScheme::Lambda.scope[:foo]
+    eval("(define foo (quote (5 5 5))")
+    assert_evals_to [5, 5, 5].to_list, :foo
+  end
+
+  def test_define_returns_defined_term
+    assert_evals_to :foo, "(define foo 2)"
+    assert_equal 2, eval("foo")
+  end
+
+  def test_eval_quote
+    assert_evals_to [:'+', 2, 2].to_list, [:quote, [:'+', 2, 2]]
+  end
+
+  def test_quote
+    assert_evals_to :hi, [:quote, :hi]
+    assert_evals_to [:a, :b, :c].to_list, "'(a b c)"
+    assert_evals_to [:a].to_list, "(list 'a)"
+    assert_evals_to [:a, :b].to_list, "(list 'a 'b)"
+    assert_evals_to [:a, :b, :c].to_list, "(list 'a 'b 'c)"
+  end
+
+  def test_if
+    assert_evals_to 7, [:if, '#f'.intern, 3, 7]
+    assert_evals_to 3, [:if, [:>, 8, 2], 3, 7]
+  end
+
+  def test_begin
+    eval([:begin,
+          [:define, :foo, 779],
+          9])
+    assert_equal 779, BusScheme::SYMBOL_TABLE[:foo]
+  end
+
+  def test_set!
+    clear_symbols(:foo)
+    # can only set! existing variables
+    assert_raises(BusScheme::EvalError) { eval "(set! foo 7)" }
+    eval "(define foo 3)"
+    eval "(set! foo 7)"
+    assert_evals_to 7, :foo
+  end
+
+  def test_consing
+    assert_evals_to BusScheme::Cons.new(:foo, :bar), "(cons (quote foo) (quote bar))"
+  end
+
+  def test_vectors
+    assert_evals_to [1, 2, 3], "#(1 2 3)"
+  end
+
+  def test_inspect
+    assert_equal "(1)", [1].to_list.inspect
+    assert_equal "(1 . 1)", BusScheme::Cons.new(1, 1).inspect
+    assert_equal "(1 1 1)", BusScheme::Cons.new(1, BusScheme::Cons.new(1, BusScheme::Cons.new(1))).inspect
+  end
+
+  def test_let
+    assert_evals_to 4, "(let ((x 2)
+                              (y 2))
+                           (+ x y))"
+
+    assert_evals_to 6, "(let ((doubler (lambda (x) (* 2 x)))
+                             (x 3))
+                           (doubler x))"
+
+    assert_evals_to 6, "(let ((doubler (lambda (x) (* 2 x)))
+                             (x 3))
+                           x
+                           (doubler x))"
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: bus-scheme
 version: !ruby/object:Gem::Version 
-  version: 0.7.1
+  version: 0.7.5
 platform: ruby
 authors: 
 - Phil Hagelberg
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-01-17 00:00:00 -08:00
+date: 2008-01-30 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -38,18 +38,22 @@ files:
 - bin/bus
 - lib/array_extensions.rb
 - lib/bus_scheme.rb
+- lib/cons.rb
 - lib/eval.rb
 - lib/lambda.rb
-- lib/definitions.rb
 - lib/object_extensions.rb
 - lib/parser.rb
+- lib/primitives.rb
+- lib/scheme/core.scm
 - test/foo.scm
+- test/test_core.rb
 - test/test_eval.rb
 - test/test_helper.rb
 - test/test_lambda.rb
 - test/test_parser.rb
+- test/test_primitives.rb
 has_rdoc: true
-homepage: "    by Phil Hagelberg (c) 2007"
+homepage: "    by Phil Hagelberg (c) 2007 - 2008"
 post_install_message: 
 rdoc_options: 
 - --main
@@ -77,7 +81,8 @@ specification_version: 2
 summary: Bus Scheme is a Scheme in Ruby, imlemented on the bus.
 test_files: 
 - test/test_lambda.rb
-- test/test_compiler.rb
+- test/test_core.rb
+- test/test_primitives.rb
 - test/test_parser.rb
 - test/test_eval.rb
 - test/test_helper.rb

data/lib/definitions.rb

@@ -1,43 +0,0 @@
-module BusScheme
-  class BusSchemeError < StandardError; end
-  class ParseError < BusSchemeError; end
-  class EvalError < BusSchemeError; end
-  class ArgumentError < BusSchemeError; end
-
-  PRIMITIVES = {
-    '#t'.intern => true, # :'#t' screws up emacs' ruby parser
-    '#f'.intern => false,
-
-    :+ => lambda { |*args| args.inject(0) { |sum, i| sum + i } },
-    :- => lambda { |x, y| x - y },
-    :* => lambda { |*args| args.inject(1) { |product, i| product * i } },
-    '/'.intern => lambda { |x, y| x / y },
-
-    :> => lambda { |x, y| x > y },
-    :< => lambda { |x, y| x < y },
-    :'=' => lambda { |x, y| x == y }, # may not honor scheme's equality notions
-    :null? => lambda { |x| x.nil? },
-    
-    :intern => lambda { |x| x.intern },
-    :substring => lambda { |x, from, to| x[from .. to] },
-
-    :car => lambda { |list| list.car },
-    :cdr => lambda { |list| list.cdr },
-
-    :ruby => lambda { |code| eval(code) },
-    :load => lambda { |filename| eval_string(File.read(filename)) },
-    :exit => lambda { exit }, :quit => lambda { exit },
-  }
-
-  # if we add in macros, can some of these be defined in scheme?
-  SPECIAL_FORMS = {
-    :quote => lambda { |arg| arg },
-    # TODO: check that nil, () and #f all behave according to spec
-    :if => lambda { |q, yes, *no| eval_form(q) ? eval_form(yes) : eval_form([:begin] + no) },
-    :begin => lambda { |*args| args.map{ |arg| eval_form(arg) }.last },
-    :set! => lambda { |sym, value| BusScheme[sym] and 
-      BusScheme[sym] = eval_form(value); sym },
-    :lambda => lambda { |args, *form| Lambda.new(args, form) },
-    :define => lambda { |sym, definition| BusScheme[sym] = eval_form(definition); sym },
-  }
-end

data/test/test_compiler.rb

@@ -1,19 +0,0 @@
-$LOAD_PATH << File.dirname(__FILE__)
-require 'test_helper'
-
-# must be run in Rubinius
-# how to check?
-
-class BusSchemeCompilerTest < Test::Unit::TestCase
-#  def test_compiles_arithmetic
-#    assert_equivalent "(+ 1 2)", "1 + 2"
-#  end
-
-  private
-  def assert_equivalent(scheme, ruby)
-    scheme = BusScheme.parse(scheme) if scheme.is_a? String # for convenience
-    parsed_ruby = ruby.to_sexp.last
-    compiled_scheme = BusScheme::Compiler.compile(scheme)
-    assert_equal 
-  end
-end