bus-scheme 0.7.5 → 0.7.6

data/lib/eval.rb

@@ -1,26 +1,59 @@
 module BusScheme
-  class << self
-    # Parse a string, then eval the result
-    def eval_string(string)
-      eval_form(parse(string))
-    end
+  module_function # did not know about this until seeing it in Rubinius; handy!
+  SYMBOL_TABLE = {} # top-level scope
+  @@stack = []
+  
+  # Parse a string, then eval the result
+  def eval_string(string)
+    eval(parse("(top-level #{string})"))
+  end
 
-    # Eval a form passed in as an array
-    def eval_form(form)
-      if form.is_a? Array or form.is_a? Cons and form.first
-        apply(form.first, *form.rest)
-      elsif form.is_a? Symbol
-        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
+  # Eval a form passed in as an array
+  def eval(form)
+    if (form.is_a?(Cons) or form.is_a?(Array)) and form.first
+      apply(form.first, form.rest)
+    elsif form.is_a? Sym
+      self[form.sym]
+    else # well it must be a literal then
+      form
     end
+  end
 
-    # Call a function with given args
-    def apply(function, *args)
-      args.map!{ |arg| eval_form(arg) } unless special_form?(function)
-      eval_form(function).call(*args)
-    end
+  # Call a function with given args
+  def apply(function_sym, args)
+    args = args.to_a
+    function = eval(function_sym)
+    args.map!{ |arg| eval(arg) } unless function.special_form
+    puts ' ' * stack.length + Cons.new(function_sym, args.sexp).inspect if (@trace ||= false)
+
+    function.call_as(function_sym, *args)
+  end
+
+  # Scoping methods:
+  def current_scope
+    @@stack.empty? ? SYMBOL_TABLE : @@stack.last
+  end
+
+  def in_scope?(sym)
+    current_scope.has_key?(sym) or SYMBOL_TABLE.has_key?(sym)
+  end
+  
+  def [](sym)
+    raise EvalError.new("Undefined symbol: #{sym.inspect}") unless in_scope?(sym)
+    current_scope[sym]
+  end
+
+  def []=(sym, val)
+    current_scope[sym] = val
+  end
+
+  # Tracing methods:
+  def stacktrace
+    # TODO: notrace is super-duper-hacky!
+    @@stack.reverse.map{ |frame| frame.trace if frame.respond_to? :trace }.compact
+  end
+
+  def stack
+    @@stack
   end
 end

data/lib/lambda.rb

@@ -1,55 +1,65 @@
 module BusScheme
-  # The RecursiveHash is needed to store Lambda environments
-  class RecursiveHash < Hash
-    # takes a hash and a parent
-    def initialize(hash, parent)
-      @parent = parent
-      hash.each { |k, v| self[k] = v }
+  # Lambdas are closures.
+  class Lambda < Cons
+    attr_reader :scope
+    attr_accessor :special_form
+    
+    # create new Lambda object
+    def initialize(formals, body)
+      @special_form = false
+      @formals, @body, @enclosing_scope = [formals, body, BusScheme.current_scope]
+      @car = :lambda.sym
+      @cdr = Cons.new(@formals.sexp, @body.sexp)
+      @called_as = nil # avoid warnings
     end
 
-    alias_method :immediate_has_key?, :has_key?
-    alias_method :immediate_set, :[]=
-    alias_method :immediate_lookup, :[]
-
-    def has_key?(symbol)
-      immediate_has_key?(symbol) or @parent && @parent.has_key?(symbol)
-    end
+    # execute body with args bound to formals
+    def call(*args)
+      locals = if @formals.is_a? Sym # rest args
+                 { @formals => args.to_list }
+               else # regular arg list
+                 raise BusScheme::ArgumentError, "Wrong number of args:
+  expected #{@formals.size}, got #{args.size}
+  #{BusScheme.stacktrace.join("\n")}" if @formals.length != args.length
+                 @formals.to_a.zip(args).to_hash
+               end
 
-    def [](symbol)
-      immediate_lookup(symbol) or @parent && @parent[symbol]
+      @frame = StackFrame.new(locals, @enclosing_scope, @called_as)
+      
+      BusScheme.stack.push @frame
+      begin
+        val = @body.map{ |form| BusScheme.eval(form) }.last
+      rescue => e
+        raise e
+        BusScheme.stack.pop
+      end
+      BusScheme.stack.pop
+      return val
     end
 
-    def []=(symbol, value)
-      if !immediate_has_key?(symbol) and @parent and @parent.has_key?(symbol)
-        @parent[symbol] = value
-      else
-        immediate_set symbol, value
-      end
+    def call_as(called_as, *args)
+      @called_as = called_as
+      call(*args)
     end
   end
 
-  # Lambdas are closures.
-  class Lambda
-    @@stack = []
-
-    attr_reader :scope
-    
-    # create new lambda object
-    def initialize(arg_names, body)
-      @arg_names, @body, @enclosing_scope = [arg_names, body, Lambda.scope]
-    end
-    
-    # execute lambda with given arg_values
-    def call(*arg_values)
-      raise BusScheme::ArgumentError if @arg_names.length != arg_values.length
-      @scope = RecursiveHash.new(@arg_names.zip(arg_values).to_hash, @enclosing_scope)
-      @@stack << self
-      BusScheme.eval_form(@body.unshift(:begin)).affect { @@stack.pop }
+  class Primitive < Lambda
+    def initialize body
+      @car = @cdr = nil # avoid "Not initialized" warnings
+      @body = body
     end
 
-    # What's the current scope?
-    def self.scope
-      @@stack.empty? ? SYMBOL_TABLE : @@stack.last.scope
+    def call(*args)
+      BusScheme.stack.push StackFrame.new({}, BusScheme.current_scope, @called_as)
+      begin
+        val = @body.call(*args)
+      rescue => e
+        BusScheme.stack.pop
+        raise e
+      end
+      BusScheme.stack.pop
+      return val
     end
   end
 end
+

data/lib/object_extensions.rb

@@ -1,3 +1,25 @@
+class Sym < String
+  attr_accessor :file, :line
+
+  # TODO: refactor?
+  def special_form
+    BusScheme[self].special_form
+  end
+  
+  def inspect
+    self
+  end
+
+  def to_s
+    self
+  end
+
+  def sym
+    self
+  end
+end
+
+
 class Object
   # Return self after evaling block
   # see http://www.ruby-forum.com/topic/131340
@@ -6,7 +28,42 @@ class Object
     return self
   end
 
-  def to_sexp
+  def sexp(r = false)
     self
   end
+  
+  def special_form
+    false
+  end
+end
+
+module Callable
+  # allows for (mylist 4) => mylist[4]
+  def call_as(sym, *args)
+    self.call(*args)
+  end
+  def call(*args)
+    self.[](*args)
+  end
+end
+
+class String
+  include Callable
+  def sym
+    Sym.new(self)
+  end
+
+  def to_html
+    self
+  end
+end
+
+class Symbol
+  def sym
+    Sym.new(self.to_s)
+  end
+end
+
+class Hash
+  include Callable
 end

data/lib/parser.rb

@@ -1,77 +1,106 @@
 module BusScheme
-  class << self
-    # Turn an input string into an S-expression
-    def parse(input)
-      parse_tokens tokenize(input).flatten
-    end
+  INVALID_IDENTIFER_BEGIN = ('0' .. '9').to_a + ['+', '-', '.']
+  
+  module_function
+
+  # Turn an input string into an S-expression
+  def parse(input)
+    @@lines = 1
+    # TODO: should sexp it as it's being constructed, not after
+    parse_tokens(tokenize(input).flatten).sexp(true)
+  end
 
-    # Turn a list of tokens into a properly-nested S-expression
-    def parse_tokens(tokens)
-      token = tokens.shift
-      if token == :'('
-        parse_list(tokens)
+  # Turn a list of tokens into a properly-nested array
+  def parse_tokens(tokens)
+    token = tokens.shift
+    if token == :'('
+      parse_list(tokens)
+    else
+      raise ParseError unless tokens.empty?
+      token # atom
+    end
+  end
+  
+  # Nest a list from a 1-dimensional list of tokens
+  def parse_list(tokens)
+    list = []
+    while element = tokens.shift and element != :')'
+      if element == :'('
+        list << parse_list(tokens)
       else
-        raise BusScheme::ParseError unless tokens.empty?
-        token # atom
+        list << element
       end
     end
+    raise IncompleteError unless element == :')'
 
-    # Nest a list from a 1-dimensional list of tokens
-    def parse_list(tokens)
-      [].affect do |list|
-        while element = tokens.shift and element != :')'
-          if element == :'('
-            list << parse_list(tokens)
-          else
-            list << element
-          end
-        end
-      end
-    end
+    parse_dots_into_cons list
+  end
 
-    # Split an input string into lexically valid tokens
-    def tokenize(input)
-      [].affect do |tokens|
-        while token = pop_token(input)
-          tokens << token
-        end
+  # Parse a "dotted cons" (1 . 2) into (cons 1 2)
+  def parse_dots_into_cons(list)
+    if(list && list.length > 0 && list[1] == :'.')
+      [:cons.sym, list.first, *list[2 .. -1]]
+    else
+      list
+    end
+  end
+    
+  # Split an input string into lexically valid tokens
+  def tokenize(input)
+    [].affect do |tokens|
+      while token = pop_token(input)
+        tokens << token
       end
     end
+  end
 
-    # 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 /\A(\s|;.*$)/ # ignore whitespace and comments
-                input[0 .. Regexp.last_match[1].length - 1] = ''
-                return pop_token(input)
-              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 /\A("(.*?)")/ # string
-                Regexp.last_match[2]
-              when /\A([^ \n\)]+)/ # symbol
-                Regexp.last_match[1].intern
-              end
+  # 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 /\A(\s|;.*$)/ # ignore whitespace and comments
+              @@lines += Regexp.last_match[1].count("\n")
+              input[0 .. Regexp.last_match[1].length - 1] = ''
+              return pop_token(input)
+            when /\A(\(|\))/ # parens
+              Regexp.last_match[1].intern
+              #              when /\A#([^\)])/
+            when /\A#\(/ # vector
+              input[0 ... 2] = ''
+              return [:'(', :vector.sym, tokenize(input)]
+            when /\A'/ # single-quote
+              input[0 ... 1] = ''
+              return [:'(', :quote.sym,
+                      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(\.)/ # dot (for pair notation), comes after float to pick up any dots that float doesn't accept
+              :'.'
+            when /\A(-?[0-9]+)/ # integer
+              Regexp.last_match[1].to_i
+            when /\A("(.*?)")/m # string
+              Regexp.last_match[2]
+              # Official Scheme valid identifiers:
+              # when /\A([A-Za-z!\$%&\*\.\/:<=>\?@\^_~][A-Za-z0-9!\$%&\*\+\-\.\/:<=>\?@\^_~]*)/ # symbol
+              # when /\A([^-0-9\. \n\)][^ \n\)]*)/
+            when /\A([^ \n\)]+)/ # symbols
+              # puts "#{Regexp.last_match[1]} - #{@@lines}"
+              # cannot begin with a character that may begin a number
+              sym = Regexp.last_match[1].sym
+              sym.file, sym.line = [BusScheme.loaded_files.last, @@lines]
+              raise ParseError, "Invalid identifier: #{sym}" if INVALID_IDENTIFER_BEGIN.include? sym[0 .. 0] and sym.size > 1
+              sym
+            else
+              raise ParseError if input =~ /[^\s ]/
+            end
 
-      # Remove the matched part from the string
-      input[0 .. Regexp.last_match[1].length - 1] = '' if token
-      return token
-    end
+    # Remove the matched part from the string
+    input[0 .. Regexp.last_match[1].length - 1] = '' if token
+    return token
   end
 end

data/lib/primitives.rb

@@ -1,45 +1,65 @@
 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 }) }
-  }
+  def self.define(identifier, value)
+    # TODO: fix if this turns out to be a good idea
+    value = Primitive.new(value) if value.is_a? Proc
+    BusScheme[identifier.sym] = value
+  end
+
+  def self.special_form(identifier, value)
+    # TODO: fix if this turns out to be a good idea
+    value = Primitive.new(value) if value.is_a? Proc
+    value.special_form = true
+    BusScheme[identifier.sym] = value
+  end
+
+  define '#t', true
+  define '#f', false
+
+  define '+', lambda { |*args| args.inject { |sum, i| sum + i } }
+  define '-', lambda { |x, y| x - y }
+  define '*', lambda { |*args| args.inject { |product, i| product * i } }
+  define '/', lambda { |x, y| x / y }
+
+  define 'concat', lambda { |*args| args.join('') }
+  define 'cons', lambda { |*args| Cons.new(*args) }
+  define 'list', lambda { |*members| members.to_list }
+  define 'vector', lambda { |*members| members.to_a }
+  define 'map', lambda { |fn, list| list.map(lambda { |n| fn.call(n) }).sexp }
+  # TODO: test these
+  define 'now', lambda { Time.now }
+  define 'regex', lambda { |r| Regexp.new(Regexp.escape(r)) }
+
+  define 'read', lambda { gets }
+  define 'write', lambda { |obj| puts obj.inspect; 0 }
+  define 'display', lambda { |obj| puts obj }
+  
+  define 'eval', lambda { |code| eval(code) }
+  define 'stacktrace', lambda { BusScheme.stacktrace }
+  define 'trace', lambda { @trace = !@trace }
+  define 'fail', lambda { |message| raise AssertionFailed, "#{message}\n  #{BusScheme.stacktrace.join("\n  ")}" }
+  
+  define 'ruby', lambda { |*code| Kernel.eval code.join('') }
+  define 'send', lambda { |obj, message, *args| obj.send(message.to_sym, *args) }
+
+  define 'load', lambda { |filename| BusScheme.load filename }
+  define 'exit', lambda { exit }
+  define 'quit', BusScheme['exit'.sym]
+
+  # TODO: hacky to coerce everything to sexps... won't work once we start using vectors
+  special_form 'quote', lambda { |arg| arg.sexp }
+  special_form 'if', lambda { |q, yes, *no| eval(eval(q) ? yes : [:begin.sym] + no) }
+  special_form 'begin', lambda { |*args| args.map{ |arg| eval(arg) }.last }
+  special_form 'top-level', BusScheme[:begin.sym]
+  special_form 'begin-notrace', lambda { |*args| args.map{ |arg| eval(arg) }.last }
+  special_form 'lambda', lambda { |args, *form| Lambda.new(args, form) }
+  # TODO: does define always create top-level bindings, or local?
+  special_form 'define', lambda { |sym, value| BusScheme::SYMBOL_TABLE[sym] = eval(value); sym }
+  special_form 'set!', lambda { |sym, value| raise EvalError.new unless BusScheme.in_scope?(sym)
+    BusScheme[sym.sym] = value }
+
+  # TODO: once we have macros, this can be defined in scheme
+  special_form 'and', lambda { |*args| args.all? { |x| eval(x) } }
+  special_form 'or', lambda { |*args| args.any? { |x| eval(x) } }
+  special_form 'let', lambda { |defs, *body| Lambda.new(defs.map{ |d| d.car }, body).call(*defs.map{ |d| eval d.last }) }
+  special_form 'hash', lambda { |*args| args.to_hash } # accepts an alist
 end