bus-scheme 0.6 → 0.7

data/Manifest.txt

@@ -6,6 +6,8 @@ bin/bus
 lib/array_extensions.rb
 lib/bus_scheme.rb
 lib/eval.rb
+lib/lambda.rb
+lib/definitions.rb
 lib/object_extensions.rb
 lib/parser.rb
 test/foo.scm

data/README.txt

@@ -37,17 +37,16 @@ $ bus foo.scm # load a file -- todo
 
 == Todo
 
-Bus Scheme is currently missing huge pieces of functionality:
+Bus Scheme is currently missing pieces of functionality:
 
-* lexical scoping
-* closures
-* loading files
-* eval input from command line, stdin
+* changes to closure variables don't affect original scope
+* optimize tail call recursion
+* continuations (?!?)
 * parse cons cells
 * parse character literals
-* numeric tower?
+* parse quote, unquote
 
-Failing tests for most of these are already included (commented out,
+Failing tests for some of these are already included (commented out,
 mostly) in the relevant test files.
 
 == Requirements

data/bin/bus

@@ -7,8 +7,8 @@ if ARGV.empty?
   BusScheme.repl
 elsif ARGV.first == '-e' and ARGV.length == 2
   puts BusScheme.eval_string(ARGV[1])
-elsif ARGV.length == 1 and File.exist?(ARGV.first) # must be a file
-  puts BusScheme.load(ARGV.first)
+elsif ARGV.length == 1 and File.exist?(ARGV.first)
+  puts BusScheme.eval_form([:load, ARGV.first])
 else
   puts "Bus Scheme: a scheme interpreter written on the bus.
 Usage: bus [file | -e \"form\"]

data/lib/array_extensions.rb

@@ -1,4 +1,10 @@
 class Array
+  def to_hash
+    {}.affect do |hash|
+      self.each { |pair| hash[pair.first] = pair.last }
+    end
+  end
+
   # Lisp-style list access
   def rest
     self[1 .. -1]
@@ -6,14 +12,4 @@ class Array
 
   alias_method :car, :first
   alias_method :cdr, :rest
-
-  # Treat the array as a lambda and call it with given args
-  def call(*args)
-    BusScheme::eval_lambda(self, args)
-  end
-
-  # Simple predicate for convenience
-  def lambda?
-    first == :lambda
-  end
 end

data/lib/bus_scheme.rb

@@ -11,71 +11,38 @@ require 'object_extensions'
 require 'array_extensions'
 require 'parser'
 require 'eval'
+require 'definitions'
+require 'lambda'
 
 module BusScheme
-  class ParseError < StandardError; end
-  class EvalError < StandardError; end
-  class ArgumentError < StandardError; end
-
-  VERSION = "0.6"
-
-  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 },
-    '/'.intern => lambda { |x, y| x / y },
-    :* => lambda { |*args| args.inject(1) { |product, i| product * i } },
-
-    :> => lambda { |x, y| x > y },
-    :< => lambda { |x, y| x < y },
-
-    :intern => lambda { |x| x.intern },
-    :concat => lambda { |x, y| x + y },
-    :substring => lambda { |x, from, to| x[from .. to] },
-
-    :exit => lambda { exit }, :quit => lambda { exit },
-  }
-
-  SPECIAL_FORMS = {
-    :quote => lambda { |arg| arg },
-    :if => lambda { |condition, yes, *no| eval_form(condition) ? eval_form(yes) : eval_form([:begin] + no) },
-    :begin => lambda { |*args| args.map{ |arg| eval_form(arg) }.last },
-    :set! => lambda { },
-    :lambda => lambda { |args, *form| [:lambda, args] + form },
-    :define => lambda { |sym, definition| BusScheme[sym] = eval_form(definition); sym },
-  }
+  VERSION = "0.7"
 
   SYMBOL_TABLE = {}.merge(PRIMITIVES).merge(SPECIAL_FORMS)
-  SCOPES = [SYMBOL_TABLE]
+  LOCAL_SCOPES = []
   PROMPT = '> '
 
-  # symbol existence predicate
-  def self.in_scope?(symbol)
-    SCOPES.last.has_key?(symbol) or SCOPES.first.has_key?(symbol)
+  # what scope is appropraite for this symbol
+  def self.scope_of(symbol)
+    ([LOCAL_SCOPES.last] + Lambda.environment + [SYMBOL_TABLE]).compact.detect { |scope| scope.has_key?(symbol) }
   end
-
+  
   # symbol lookup
   def self.[](symbol)
-    SCOPES.last[symbol] or SCOPES.first[symbol]
+    scope = scope_of(symbol)
+    raise EvalError.new("Undefined symbol: #{symbol}") if scope.nil?
+    scope[symbol]
   end
 
   # symbol assignment to value
   def self.[]=(symbol, value)
-    SCOPES.last[symbol] = value
-  end
-
-  # remove symbols from all scopes
-  def self.clear_symbols(*symbols)
-    SCOPES.map{ |scope| symbols.map{ |sym| scope.delete sym } }
+    (scope_of(symbol) || SYMBOL_TABLE)[symbol] = value
   end
 
   # symbol special form predicate
   def self.special_form?(symbol)
     SPECIAL_FORMS.has_key?(symbol)
   end
-
+  
   # Read-Eval-Print-Loop
   def self.repl
     loop do
@@ -83,6 +50,11 @@ module BusScheme
         puts BusScheme.eval_string(Readline.readline(PROMPT))
       rescue Interrupt
         puts 'Type "(quit)" to leave Bus Scheme.'
+      rescue BusSchemeError => e
+        puts "Error: #{e}"
+      rescue StandardError => e
+        puts "You found a bug in Bus Scheme!"
+        puts "#{e.class}: #{e}\n#{e.backtrace.join("\n")}"
       end
     end
   end

data/lib/definitions.rb

@@ -0,0 +1,38 @@
+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 },
+
+    :intern => lambda { |x| x.intern },
+    :concat => lambda { |x, y| x + y },
+    :substring => lambda { |x, from, to| x[from .. to] },
+
+    :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/lib/eval.rb

@@ -12,9 +12,8 @@ module BusScheme
       elsif form.is_a? Array
         apply(form.first, *form.rest)
       elsif form.is_a? Symbol
-        raise "Undefined symbol: #{form}" unless in_scope?(form)
         BusScheme[form]
-      else
+      else # well it must be a literal then
         form
       end
     end
@@ -22,30 +21,7 @@ module BusScheme
     # Call a function with given args
     def apply(function, *args)
       args.map!{ |arg| eval_form(arg) } unless special_form?(function)
-
-      # refactor me
-      if function.is_a?(Array) and function.lambda?
-        function.call(*args)
-      else
-        raise "Undefined symbol: #{function}" unless in_scope?(function)
-        BusScheme[function].call(*args)
-      end
-    end
-
-    # All the super lambda magic happens (or fails to happen) here
-    def eval_lambda(lambda, args)
-      raise BusScheme::EvalError unless lambda.shift == :lambda
-
-      arg_list = lambda.shift
-      raise BusScheme::ArgumentError if !arg_list.is_a?(Array) or arg_list.length != args.length
-
-      SCOPES << {} # new scope
-      until arg_list.empty?
-        BusScheme[arg_list.shift] = args.shift
-      end
-
-      # using affect as a non-return-value-affecting callback
-      BusScheme[:begin].call(*lambda).affect { SCOPES.pop }
+      eval_form(function).call(*args)
     end
   end
 end

data/lib/lambda.rb

@@ -0,0 +1,32 @@
+module BusScheme
+  class Lambda
+    @@current = nil
+    
+    # create new lambda object
+    def initialize(arg_names, body)
+      @arg_names, @body, @environment = [arg_names, body, LOCAL_SCOPES]
+    end
+
+    attr_reader :environment
+    
+    # execute lambda with given arg_values
+    def call(*arg_values)
+      raise BusScheme::ArgumentError if @arg_names.length != arg_values.length
+      with_local_scope(@arg_names.zip(arg_values).to_hash) { BusScheme[:begin].call(*@body) }
+    end
+
+    def self.environment
+      @@current ? @@current.environment : []
+    end
+    
+    # execute a block with a given local scope
+    def with_local_scope(scope, &block)
+      BusScheme::LOCAL_SCOPES << scope
+      @@current = self
+      block.call.affect do
+        BusScheme::LOCAL_SCOPES.delete(scope)
+        @@current = nil
+      end
+    end
+  end
+end

data/test/test_eval.rb

@@ -35,7 +35,7 @@ class BusSchemeEvalTest < Test::Unit::TestCase
   end
 
   def test_define
-    BusScheme.clear_symbols :foo
+    clear_symbols :foo
     eval("(define foo 5)")
     assert_equal 5, BusScheme[:foo]
     eval("(define foo (quote (5 5 5))")
@@ -44,7 +44,6 @@ class BusSchemeEvalTest < Test::Unit::TestCase
 
   def test_define_returns_defined_term
     assert_evals_to :foo, "(define foo 2)"
-    # can't use the eval convenience testing method since it assumes strings are unparsed
     assert_equal 2, eval("foo")
   end
 
@@ -72,7 +71,7 @@ class BusSchemeEvalTest < Test::Unit::TestCase
   end
 
   def test_blows_up_with_undefined_symbol
-    assert_raises(RuntimeError) { eval("undefined-symbol") }
+    assert_raises(BusScheme::EvalError) { eval("undefined-symbol") }
   end
 
   def test_variable_substitution
@@ -94,65 +93,16 @@ class BusSchemeEvalTest < Test::Unit::TestCase
   end
 
   def test_set!
-    # i dunno... what does set! do? how's it different from define?
-  end
-
-  def test_simple_lambda
-    assert_equal [:lambda, [], [:+, 1, 1]], eval("(lambda () (+ 1 1))")
-    eval("(define foo (lambda () (+ 1 1)))")
-    assert_equal :lambda, BusScheme[:foo].first
-    assert_evals_to 2, [:foo]
-  end
-
-  def test_lambda_with_arg
-    eval("(define foo (lambda (x) (+ x 1)))")
-    assert_evals_to 2, [:foo, 1]
-  end
-
-  def test_eval_literal_lambda
-    assert_evals_to 4, "((lambda (x) (* x x)) 2)"
-  end
-
-  def test_lambda_with_incorrect_arity
-    eval("(define foo (lambda (x) (+ x 1)))")
-    assert_raises(BusScheme::ArgumentError) { assert_evals_to 2, [:foo, 1, 3] }
-  end
-
-  def test_lambda_args_dont_stay_in_scope
-    BusScheme.clear_symbols(:x, :foo)
-    eval("(define foo (lambda (x) (+ x 1)))")
-    assert !BusScheme.in_scope?(:x)
-    assert_evals_to 2, [:foo, 1]
-    assert !BusScheme.in_scope?(:x)
-  end
-
-  #   def test_lexical_scoping
-  #     assert_raises(BusScheme::EvalError) do
-  #       eval "???"
-  #     end
-  #   end
-
-  #   def test_lambda_closures
-  #     eval "(define foo (lambda (x) ((lambda (y) (+ x y)) (* x 2))))"
-  #     assert_evals_to 3, [:foo, 1]
-  #   end
-
-  #   def test_load_file
-  #     eval "(load \"#{File.dirname(__FILE__)}/foo.scm\")"
-  #     assert_evals_to 3, :foo
-  #   end
-
-  private
-
-  def eval(form) # convenience method that accepts string or form
-    if form.is_a?(String)
-      BusScheme.eval_string(form)
-    else
-      BusScheme.eval_form(form)
-    end
+    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 assert_evals_to(expected, form)
-    assert_equal expected, eval(form)
+  def test_load_file
+    eval "(load \"#{File.dirname(__FILE__)}/foo.scm\")"
+    assert_evals_to 3, :foo
   end
 end

data/test/test_helper.rb

@@ -8,3 +8,20 @@ end
 $LOAD_PATH << File.dirname(__FILE__) + '/../lib/'
 require 'test/unit'
 require 'bus_scheme'
+
+def eval(form) # convenience method that accepts string or form
+  if form.is_a?(String)
+    BusScheme.eval_string(form)
+  else
+    BusScheme.eval_form(form)
+  end
+end
+
+def assert_evals_to(expected, form)
+  assert_equal expected, eval(form)
+end
+
+# remove symbols from all scopes
+def clear_symbols(*symbols)
+  (BusScheme::LOCAL_SCOPES << BusScheme::SYMBOL_TABLE).map{ |scope| symbols.map{ |sym| scope.delete sym } }
+end

data/test/test_lambda.rb

@@ -0,0 +1,60 @@
+$LOAD_PATH << File.dirname(__FILE__)
+require 'test_helper'
+
+class BusScheme::Lambda
+  attr_accessor :body, :arg_names, :environment
+end
+
+class BusSchemeLambdaTest < Test::Unit::TestCase
+  def test_simple_lambda
+    l = eval("(lambda () (+ 1 1))")
+    assert l.is_a?(BusScheme::Lambda)
+    assert_equal [[:+, 1, 1]], l.body
+    assert_equal [], l.arg_names
+
+    eval("(define foo (lambda () (+ 1 1)))")
+    assert BusScheme[:foo].is_a?(BusScheme::Lambda)
+    assert_evals_to 2, [:foo]
+  end
+
+  def test_lambda_with_arg
+    eval("(define foo (lambda (x) (+ x 1)))")
+    assert_evals_to 2, [:foo, 1]
+  end
+
+  def test_eval_literal_lambda
+    assert_evals_to 4, "((lambda (x) (* x x)) 2)"
+  end
+
+  def test_lambda_with_incorrect_arity
+    eval("(define foo (lambda (x) (+ x 1)))")
+    assert_raises(BusScheme::ArgumentError) { assert_evals_to 2, [:foo, 1, 3] }
+  end
+
+  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_evals_to 2, [:foo, 1]
+    assert_nil BusScheme.scope_of(:x)
+  end
+
+  def test_lambda_calls_lambda
+    eval "(define f (lambda (x) (+ 3 x)))"
+    eval "(define g (lambda (y) (* 3 y)))"
+    assert_evals_to 12, "(f (g 3))"
+  end
+
+  def test_lambda_closures
+    eval "(define foo (lambda (x) ((lambda (y) (+ x y)) (* x 2))))"
+    assert_evals_to 3, [:foo, 1]
+  end
+
+  def test_changes_to_enclosed_variables_are_in_effect_after_lambda_execution
+    assert_evals_to 2, "((lambda (x) (begin ((lambda () (set! x 2))) x)) 1)"
+  end
+
+  def test_implicit_begin
+    assert_evals_to 3, "((lambda () (intern \"hi\") (+ 2 2) (* 1 3)))"
+  end
+end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: bus-scheme
 version: !ruby/object:Gem::Version 
-  version: "0.6"
-platform: ""
+  version: "0.7"
+platform: ruby
 authors: 
 - Phil Hagelberg
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2007-12-17 00:00:00 -08:00
+date: 2008-01-10 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -19,7 +19,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.3.0
+        version: 1.4.0
     version: 
 description: Bus Scheme is a Scheme written in Ruby, but implemented on the bus! Every programmer must implement Scheme as a rite of passage; this is mine. Note that all the implementation of Bus Scheme must be written while on a bus. Documentation, tests, and administrivia may be accomplished elsewhere, but all actual implementation code is strictly bus-driven. Patches are welcome as long as they were written while riding a bus. (If your daily commute does not involve a bus but you want to submit a patch, we may be able to work something out regarding code written on trains, ferries, or perhaps even carpool lanes.) Bus Scheme is primarily a toy; using it for anything serious is (right now) ill-advised.  Bus Scheme aims for general Scheme usefulness optimized for learning and fun. It's not targeting R5RS or anything like that.  == Install  * sudo gem install bus-scheme
 email: technomancy@gmail.com
@@ -39,6 +39,8 @@ files:
 - lib/array_extensions.rb
 - lib/bus_scheme.rb
 - lib/eval.rb
+- lib/lambda.rb
+- lib/definitions.rb
 - lib/object_extensions.rb
 - lib/parser.rb
 - test/foo.scm
@@ -68,11 +70,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: bus-scheme
-rubygems_version: 0.9.5
+rubygems_version: 1.0.0
 signing_key: 
 specification_version: 2
 summary: Bus Scheme is a Scheme in Ruby, imlemented on the bus.
 test_files: 
+- test/test_lambda.rb
 - test/test_parser.rb
-- test/test_helper.rb
 - test/test_eval.rb
+- test/test_helper.rb