heist 0.1.0 → 0.2.0

data/lib/builtin/primitives.rb

@@ -1,34 +1,35 @@
 # Functions that create new functions
 
-# (define) binds values to names in the current scope.
-# If the first parameter is a list it creates a function,
-# otherwise it eval's the second parameter and binds it
-# to the name given by the first.
-syntax('define') do |scope, names, *body|
-  List === names ?
-      scope.define(names.first, names.rest, body) :
-      scope[names] = Heist.evaluate(body.first, scope)
+# (define) binds values to names in the current scope. If the
+# first parameter is a list it creates a function, otherwise
+# it eval's the second parameter and binds it to the name
+# given by the first.
+syntax('define') do |scope, cells|
+  name = cells.car
+  Cons === name ?
+      scope.define(name.car, name.cdr, cells.cdr) :
+      scope[name] = Heist.evaluate(cells.cdr.car, scope)
 end
 
-# (lambda) returns an anonymous function whose arguments
-# are named by the first parameter and whose body is given
-# by the remaining parameters.
-syntax('lambda') do |scope, names, *body|
-  Function.new(scope, names, body)
+# (lambda) returns an anonymous function whose arguments are
+# named by the first parameter and whose body is given by the
+# remaining parameters.
+syntax('lambda') do |scope, cells|
+  Function.new(scope, cells.car, cells.cdr)
 end
 
 # (set!) reassigns the value of an existing bound variable,
 # in the innermost scope responsible for binding it.
-syntax('set!') do |scope, name, value|
-  scope.set!(name, Heist.evaluate(value, scope))
+syntax('set!') do |scope, cells|
+  scope.set!(cells.car, Heist.evaluate(cells.cdr.car, scope))
 end
 
 #----------------------------------------------------------------
 
 # Macros
 
-syntax('define-syntax') do |scope, name, transformer|
-  scope[name] = Heist.evaluate(transformer, scope)
+syntax('define-syntax') do |scope, cells|
+  scope[cells.car] = Heist.evaluate(cells.cdr.car, scope)
 end
 
 syntax('let-syntax') do |*args|
@@ -39,65 +40,34 @@ syntax('letrec-syntax') do |*args|
   call('letrec', *args)
 end
 
-syntax('syntax-rules') do |scope, keywords, *rules|
-  Macro.new(scope, keywords, rules)
+syntax('syntax-rules') do |scope, cells|
+  Macro.new(scope, cells.car, cells.cdr)
 end
 
 #----------------------------------------------------------------
 
 # Continuations
 
-syntax('call-with-current-continuation') do |scope, callback|
+# Creates a +Continuation+ encapsulating the current +Stack+
+# state, and returns the result of calling the second parameter
+# (which should evaluate to a +Function+) with the continuation
+# as the argument.
+syntax('call-with-current-continuation') do |scope, cells|
   continuation = Continuation.new(scope.runtime.stack)
-  callback = Heist.evaluate(callback, scope)
-  callback.call(scope, [continuation])
+  callback = Heist.evaluate(cells.car, scope)
+  callback.call(scope, Cons.new(continuation))
 end
 
 #----------------------------------------------------------------
 
 # Quoting functions
 
-# (quote) casts identifiers to symbols. If given a list, it
-# quotes all items in the list recursively.
-syntax('quote') do |scope, arg|
-  case arg
-  when List then
-    arg.inject(List.new) do |list, cell|
-      list << call('quote', scope, cell)
-      list
-    end
-  when Identifier then arg.to_s.to_sym
-  else arg
-  end
-end
-
-# (quasiquote) is similar to (quote), except that when it
-# encounters an (unquote) or (unquote-splicing) expression
-# it will evaluate it and insert the result into the
-# surrounding quoted list.
-syntax('quasiquote') do |scope, arg|
-  case arg
-  when List then
-    result = List.new
-    arg.each do |cell|
-      if List === cell
-        case cell.first.to_s
-        when 'unquote' then
-          result << Heist.evaluate(cell.last, scope)
-        when 'unquote-splicing' then
-          list = Heist.evaluate(cell.last, scope)
-          list.each { |value| result << value }
-        else
-          result << call('quasiquote', scope, cell)
-        end
-      else
-        result << call('quasiquote', scope, cell)
-      end
-    end
-    result
-  when Identifier then arg.to_s.to_sym
-  else arg
-  end
+# (quote) treats its argument as a literal. Returns the given
+# portion of the parse tree as a list
+syntax('quote') do |scope, cells|
+  node = cells.car
+  node.freeze! if node.respond_to?(:freeze!)
+  node
 end
 
 #----------------------------------------------------------------
@@ -105,39 +75,52 @@ end
 # Control structures
 
 # (begin) simply executes a series of lists in the current scope.
-syntax('begin') do |scope, *body|
-  Body.new(body, scope)
+syntax('begin') do |scope, cells|
+  Body.new(cells, scope)
 end
 
 # (if) evaluates the consequent if the condition eval's to
 # true, otherwise it evaluates the alternative
-syntax('if') do |scope, cond, cons, alt|
-  which = Heist.evaluate(cond, scope) ? cons : alt
-  Frame.new(which, scope)
+syntax('if') do |scope, cells|
+  which = Heist.evaluate(cells.car, scope) ? cells.cdr : cells.cdr.cdr
+  which.null? ? which : Frame.new(which.car, scope)
 end
 
 #----------------------------------------------------------------
 
 # Runtime utilities
 
+# (exit) causes the host Ruby process to quit
 define('exit') { exit }
 
-syntax('runtime') do |scope|
+# (runtime) returns the amount of time the host +Runtime+ has
+# been alive, in microseconds. Not a standard function, but
+# used in SICP.
+syntax('runtime') do |scope, cells|
   scope.runtime.elapsed_time
 end
 
-syntax('eval') do |scope, string|
-  scope.eval(Heist.evaluate(string, scope))
+# (eval) evaluates Scheme code and returns the result. The
+# argument can be a string or a list containing a valid
+# Scheme expression.
+syntax('eval') do |scope, cells|
+  scope.eval(Heist.evaluate(cells.car, scope))
 end
 
+# (display) prints the given value to the console
 define('display') do |expression|
   print expression
 end
 
-syntax('load') do |scope, file|
-  scope.load(file)
+# (load) loads a file containing Scheme code and executes its
+# contents. The path can be relative to the current file, or
+# it can be the name of a file in the Heist library.
+syntax('load') do |scope, cells|
+  scope.load(cells.car)
 end
 
+# (error) raises an error with the given message. Additional
+# arguments are appended to the message.
 define('error') do |message, *args|
   raise RuntimeError.new("#{ message } :: #{ args * ', ' }")
 end
@@ -146,9 +129,21 @@ end
 
 # Comparators
 
-# TODO write a more exact implementation, and implement (eq?) and (equal?)
+# TODO write a more exact implementation, and implement (eq?)
 define('eqv?') do |op1, op2|
-  op1.class == op2.class and op1 == op2
+  (Identifier === op1 and op1 == op2) or op1.equal?(op2)
+end
+
+define('equal?') do |op1, op2|
+  op1 == op2
+end
+
+# Returns true iff the given number is exact i.e. an integer, a
+# rational, or a complex made of integers
+define('exact?') do |value|
+  call('rational?', value) || (Complex === value &&
+                               call('rational?', value.real) &&
+                               call('rational?', value.imag))
 end
 
 # TODO raise an exception if they're not numeric
@@ -190,39 +185,43 @@ end
 # Type-checking predicates
 
 define('complex?') do |value|
-  call('real?', value) # || TODO
+  Complex === value || call('real?', value)
 end
 
 define('real?') do |value|
-  call('rational?', value) || Float === value
+  Float === value || call('rational?', value)
 end
 
 define('rational?') do |value|
-  call('integer?', value) || Float === value # TODO handle this properly
+  Rational === value || call('integer?', value)
 end
 
 define('integer?') do |value|
   Integer === value
 end
 
-#----------------------------------------------------------------
-
-# Numerical functions
-# TODO implement exact?, inexact?, numerator, denominator, rationalize,
-#                complex functions, exact->inexact and vice versa
+define('string?') do |value|
+  String === value
+end
 
-# TODO implement max/min in Scheme
+define('symbol?') do |value|
+  Symbol === value or Identifier === value
+end
 
-# Returns the maximum value in the list of arguments
-define('max') do |*args|
-  args.max
+define('procedure?') do |value|
+  Function === value
 end
 
-# Returns the minimum value in the list of arguments
-define('min') do |*args|
-  args.min
+define('pair?') do |value|
+  Cons === value and value.pair?
 end
 
+#----------------------------------------------------------------
+
+# Numerical functions
+# TODO implement exact?, inexact?, numerator, denominator, rationalize,
+#                complex functions, exact->inexact and vice versa
+
 # Returns the sum of all arguments passed
 define('+') do |*args|
   args.any? { |arg| String === arg } ?
@@ -243,7 +242,7 @@ end
 # Returns the first argument divided by the second, or the
 # reciprocal of the first if only one argument is given
 define('/') do |op1, op2|
-  op2.nil? ? 1.0 / op1 : op1 / op2.to_f
+  op2.nil? ? Heist.divide(1, op1) : Heist.divide(op1, op2)
 end
 
 # (quotient) and (remainder) satisfy
@@ -269,6 +268,16 @@ define('modulo') do |op1, op2|
   op1.to_i % op2.to_i
 end
 
+# Returns the numerator of a number
+define('numerator') do |value|
+  Rational === value ? value.numerator : value
+end
+
+# Returns the denominator of a number
+define('denominator') do |value|
+  Rational === value ? value.denominator : 1
+end
+
 %w[floor ceil truncate round].each do |symbol|
   define(symbol) do |number|
     number.__send__(symbol)
@@ -291,16 +300,69 @@ define('expt') do |op1, op2|
   op1 ** op2
 end
 
+# Returns a new complex number with the given real and
+# imaginary parts
+define('make-rectangular') do |real, imag|
+  Complex.new(real, imag)
+end
+
+# Returns the real part of a number
+define('real-part') do |value|
+  Complex === value ? value.real : value
+end
+
+# Returns the imaginary part of a number, which is zero
+# unless the number is not real
+define('imag-part') do |value|
+  Complex === value ? value.imag : 0
+end
+
 # Returns a random number in the range 0...max
 define('random') do |max|
   rand(max)
 end
 
+# Casts a number to a string
 define('number->string') do |number, radix|
   number.to_s(radix || 10)
-end
 
+end
+# Casts a string to a number
 define('string->number') do |string, radix|
   radix.nil? ? string.to_f : string.to_i(radix)
 end
 
+#----------------------------------------------------------------
+
+# List/pair functions
+
+# Allocates and returns a new pair from its arguments
+define('cons') do |car, cdr|
+  Cons.new(car, cdr)
+end
+
+# car/cdr accessors (dynamically generated)
+Cons::ACCESSORS.each do |accsr|
+  define(accsr) do |cons|
+    cons.__send__(accsr)
+  end
+end
+
+# Mutators for car/cdr fields
+define('set-car!') do |cons, value|
+  cons.car = value
+end
+define('set-cdr!') do |cons, value|
+  cons.cdr = value
+end
+
+#----------------------------------------------------------------
+
+# Control features
+
+# Calls a function using a list for the arguments
+# TODO take multiple argument values instead of a single list
+define('apply') do |function, list|
+  function.apply(list.to_a)
+end
+

data/lib/builtin/syntax.scm

@@ -27,16 +27,13 @@
   [(case key) #f]
   [(case key (else expr1 expr2 ...))
     (begin expr1 expr2 ...)]
-  [(case key (() expr ...) clause ...)
-    (case key clause ...)]
   [(case key
-         ((datum1 datum2 ...) expr1 expr2 ...)
+         ((cell ...) expr1 expr2 ...)
          clause ...)
     (let ([temp key])
-      (if (eqv? temp 'datum1)
+      (if (member temp '(cell ...))
           (begin expr1 expr2 ...)
           (case temp
-                ((datum2 ...) expr1 expr2 ...)
                 clause ...)))]))
 
 ;----------------------------------------------------------------
@@ -153,3 +150,23 @@
               (set! forced #t)
               memo))))]))
 
+;----------------------------------------------------------------
+
+; Quasiquotation
+
+; (quasiquote) is similar to (quote), except that when it
+; encounters an (unquote) or (unquote-splicing) expression
+; it will evaluate it and insert the result into the
+; surrounding quoted list.
+(define-syntax quasiquote (syntax-rules (unquote unquote-splicing)
+  [(quasiquote (unquote expr))
+    expr]
+  [(quasiquote ((unquote-splicing expr)))
+    expr]
+  [(quasiquote ((unquote-splicing expr) . rest))
+    (append expr (quasiquote rest))]
+  [(quasiquote (first . rest))
+    (cons (quasiquote first) (quasiquote rest))]
+  [(quasiquote expr)
+    'expr]))
+

data/lib/heist.rb

@@ -1,8 +1,15 @@
+require 'forwardable'
+require 'rational'
+require 'complex'
+
 require 'rubygems'
 require 'treetop'
 
+# +Heist+ is the root module for all of Heist's components, and hosts a few
+# utility methods that don't belong anywhere else. See the README for an
+# overview of Heist's features.
 module Heist
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
   
   ROOT_PATH    = File.expand_path(File.dirname(__FILE__))
   PARSER_PATH  = ROOT_PATH + '/parser/'
@@ -10,6 +17,7 @@ module Heist
   BUILTIN_PATH = ROOT_PATH + '/builtin/'
   LIB_PATH     = ROOT_PATH + '/stdlib/'
   
+  require PARSER_PATH + 'ruby'
   require PARSER_PATH + 'scheme'
   require PARSER_PATH + 'nodes'
   require RUNTIME_PATH + 'runtime'
@@ -24,23 +32,47 @@ module Heist
   class SyntaxError           < RuntimeError; end
   class MacroError            < SyntaxError; end
   class MacroTemplateMismatch < MacroError; end
+  class TypeError             < RuntimeError; end
+  class ImmutableError        < TypeError; end
   
-  def self.parse(source)
-    @parser ||= SchemeParser.new
-    @parser.parse(source)
-  end
-  
-  def self.evaluate(expression, scope)
-    Runtime::Expression === expression ?
-        expression.eval(scope) :
-        expression
-  end
-  
-  def self.info(runtime)
-    puts "Heist Scheme interpreter v. #{ VERSION }"
-    puts "Evaluation mode: #{ runtime.lazy? ? 'LAZY' : 'EAGER' }"
-    puts "Continuations enabled? #{ runtime.stackless? ? 'NO' : 'YES' }"
-    puts "Macros: #{ runtime.hygienic? ? 'HYGIENIC' : 'UNHYGIENIC' }\n\n"
+  class << self
+    # Accepts either a string of Scheme code or an array of Ruby data and parses
+    # into a +Cons+ list structure. Scheme code is converted to a +Program+,
+    # while a Ruby array is converted to a single list expression. Returns +nil+
+    # if the input cannot be parsed successfully.
+    def parse(source)
+      @scheme ||= SchemeParser.new
+      @ruby   ||= RubyParser.new
+      parser = (String === source) ? @scheme : @ruby
+      parser.parse(source)
+    end
+    
+    # Returns the result of evaluating the given +Expression+ in the given +Scope+.
+    # If the first argument is not an +Expression+ it will be returned unaltered.
+    def evaluate(expression, scope)
+      Runtime::Expression === expression ?
+          expression.eval(scope) :
+          expression
+    end
+    
+    # Returns a new complex number with the given +real+ and +imaginary+ parts.
+    def complex(real, imaginary)
+      Complex.new(real, imaginary)
+    end
+    
+    # Returns a new rational number with the given +numerator+ and +denominator+.
+    def rational(numerator, denominator)
+      Rational(numerator, denominator)
+    end
+    
+    # Returns the result of dividing the first argument by the second. If both
+    # arguments are integers, returns a rational rather than performing
+    # integer division as Ruby would normally do.
+    def divide(op1, op2)
+      [op1, op2].all? { |value| Integer === value } ?
+          rational(op1, op2) :
+          op1.to_f / op2
+    end
   end
   
 end