heist 0.1.0

data/lib/builtin/primitives.rb

@@ -0,0 +1,306 @@
+# 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)
+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)
+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))
+end
+
+#----------------------------------------------------------------
+
+# Macros
+
+syntax('define-syntax') do |scope, name, transformer|
+  scope[name] = Heist.evaluate(transformer, scope)
+end
+
+syntax('let-syntax') do |*args|
+  call('let', *args)
+end
+
+syntax('letrec-syntax') do |*args|
+  call('letrec', *args)
+end
+
+syntax('syntax-rules') do |scope, keywords, *rules|
+  Macro.new(scope, keywords, rules)
+end
+
+#----------------------------------------------------------------
+
+# Continuations
+
+syntax('call-with-current-continuation') do |scope, callback|
+  continuation = Continuation.new(scope.runtime.stack)
+  callback = Heist.evaluate(callback, scope)
+  callback.call(scope, [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
+end
+
+#----------------------------------------------------------------
+
+# Control structures
+
+# (begin) simply executes a series of lists in the current scope.
+syntax('begin') do |scope, *body|
+  Body.new(body, 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)
+end
+
+#----------------------------------------------------------------
+
+# Runtime utilities
+
+define('exit') { exit }
+
+syntax('runtime') do |scope|
+  scope.runtime.elapsed_time
+end
+
+syntax('eval') do |scope, string|
+  scope.eval(Heist.evaluate(string, scope))
+end
+
+define('display') do |expression|
+  print expression
+end
+
+syntax('load') do |scope, file|
+  scope.load(file)
+end
+
+define('error') do |message, *args|
+  raise RuntimeError.new("#{ message } :: #{ args * ', ' }")
+end
+
+#----------------------------------------------------------------
+
+# Comparators
+
+# TODO write a more exact implementation, and implement (eq?) and (equal?)
+define('eqv?') do |op1, op2|
+  op1.class == op2.class and op1 == op2
+end
+
+# TODO raise an exception if they're not numeric
+# Returns true iff all arguments are numerically equal
+define('=') do |*args|
+  args.all? { |arg| arg == args.first }
+end
+
+# Returns true iff the arguments are monotonically decreasing
+define('>') do |*args|
+  result = true
+  args.inject { |former, latter| result = false unless former > latter }
+  result
+end
+
+# Returns true iff the arguments are monotonically non-increasing
+define('>=') do |*args|
+  result = true
+  args.inject { |former, latter| result = false unless former >= latter }
+  result
+end
+
+# Returns true iff the arguments are monotonically increasing
+define('<') do |*args|
+  result = true
+  args.inject { |former, latter| result = false unless former < latter }
+  result
+end
+
+# Returns true iff the arguments are monotonically non-decreasing
+define('<=') do |*args|
+  result = true
+  args.inject { |former, latter| result = false unless former <= latter }
+  result
+end
+
+#----------------------------------------------------------------
+
+# Type-checking predicates
+
+define('complex?') do |value|
+  call('real?', value) # || TODO
+end
+
+define('real?') do |value|
+  call('rational?', value) || Float === value
+end
+
+define('rational?') do |value|
+  call('integer?', value) || Float === value # TODO handle this properly
+end
+
+define('integer?') do |value|
+  Integer === value
+end
+
+#----------------------------------------------------------------
+
+# Numerical functions
+# TODO implement exact?, inexact?, numerator, denominator, rationalize,
+#                complex functions, exact->inexact and vice versa
+
+# TODO implement max/min in Scheme
+
+# Returns the maximum value in the list of arguments
+define('max') do |*args|
+  args.max
+end
+
+# Returns the minimum value in the list of arguments
+define('min') do |*args|
+  args.min
+end
+
+# Returns the sum of all arguments passed
+define('+') do |*args|
+  args.any? { |arg| String === arg } ?
+      args.inject("") { |str, arg| str + arg.to_s } :
+      args.inject(0)  { |sum, arg| sum + arg }
+end
+
+# Subtracts the second argument from the first
+define('-') do |op1, op2|
+  op2.nil? ? 0 - op1 : op1 - op2
+end
+
+# Returns the product of all arguments passed
+define('*') do |*args|
+  args.inject(1) { |prod, arg| prod * arg }
+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
+end
+
+# (quotient) and (remainder) satisfy
+# 
+# (= n1 (+ (* n2 (quotient n1 n2))
+#          (remainder n1 n2)))
+
+# Returns the quotient of two numbers, i.e. performs n1/n2
+# and rounds toward zero.
+define('quotient') do |op1, op2|
+  result = op1.to_i.to_f / op2.to_i
+  result > 0 ? result.floor : result.ceil
+end
+
+# Returns the remainder after dividing the first operand
+# by the second
+define('remainder') do |op1, op2|
+  op1.to_i - op2.to_i * call('quotient', op1, op2)
+end
+
+# Returns the first operand modulo the second
+define('modulo') do |op1, op2|
+  op1.to_i % op2.to_i
+end
+
+%w[floor ceil truncate round].each do |symbol|
+  define(symbol) do |number|
+    number.__send__(symbol)
+  end
+end
+
+%w[exp log sin cos tan asin acos sqrt].each do |symbol|
+  define(symbol) do |number|
+    Math.__send__(symbol, number)
+  end
+end
+
+define('atan') do |op1, op2|
+  op2.nil? ? Math.atan(op1) : Math.atan2(op1, op2)
+end
+
+# Returns the result of raising the first argument to the
+# power of the second
+define('expt') do |op1, op2|
+  op1 ** op2
+end
+
+# Returns a random number in the range 0...max
+define('random') do |max|
+  rand(max)
+end
+
+define('number->string') do |number, radix|
+  number.to_s(radix || 10)
+end
+
+define('string->number') do |string, radix|
+  radix.nil? ? string.to_f : string.to_i(radix)
+end
+

data/lib/builtin/syntax.rb

@@ -0,0 +1,166 @@
+# Control structures
+
+# (cond) goes through a list of tests, evaluating each one
+# in order of appearance. Once a matching precondition is
+# found, its consequent is tail-called and no further
+# preconditions are evaluated.
+syntax('cond') do |scope, *pairs|
+  result = nil
+  pairs.each do |list|
+    next if result
+    test = list.first.to_s == 'else' || Heist.evaluate(list.first, scope)
+    next unless test
+    result = list[1].to_s == '=>' ?
+             Heist.evaluate(list[2], scope).call(scope, [test]) :
+             Body.new(list.rest, scope)
+  end
+  result
+end
+
+# (case) acts like Ruby's case statement. The value of the
+# given expression is compared against a series of lists;
+# once a list is found to include the value, the expressions
+# following the list are evaluated and no further lists
+# are tested.
+syntax('case') do |scope, key, *clauses|
+  value = Heist.evaluate(key, scope)
+  result = nil
+  clauses.each do |list|
+    next if result
+    values = call('quote', scope, list.first)
+    result = Body.new(list.rest, scope) if values == :else or
+                                           values.include?(value)
+  end
+  result
+end
+
+#----------------------------------------------------------------
+
+# Binding constructs
+
+# (let), (let*) and (letrec) each create a new scope and bind
+# values to some symbols before executing a series of lists.
+# They differ according to how they evaluate the bound values.
+
+# (let) evaluates values in the enclosing scope, so lambdas will
+# not be able to refer to other values assigned using the (let).
+syntax('let') do |scope, assignments, *body|
+  if Identifier === assignments
+    name = assignments
+    assignments = body.first
+    formals = assignments.map { |pair| pair.first }
+    values  = assignments.map { |pair| pair.last }
+    closure = Scope.new(scope)
+    closure[name] = Function.new(closure, formals, body[1..-1])
+    closure[name].call(scope, values)
+  else
+    closure = Scope.new(scope)
+    assignments.each do |assign|
+      closure[assign.first] = Heist.evaluate(assign.last, scope)
+    end
+    call('begin', closure, *body)
+  end
+end
+
+# (let*) creates a new scope for each variable and evaluates
+# each expression in its enclosing scope. Basically a shorthand
+# for several nested (let)s. Variables may refer to those that
+# preceed them but not vice versa.
+syntax('let*') do |scope, assignments, *body|
+  closure = assignments.inject(scope) do |outer, assign|
+    inner = Scope.new(outer)
+    inner[assign.first] = Heist.evaluate(assign.last, outer)
+    inner
+  end
+  call('begin', closure, *body)
+end
+
+# (letrec) evaluates values in the inner scope, so lambdas are
+# able to refer to other values assigned using the (letrec).
+syntax('letrec') do |scope, assignments, *body|
+  closure = Scope.new(scope)
+  assignments.each do |assign|
+    closure[assign.first] = Heist.evaluate(assign.last, closure)
+  end
+  call('begin', closure, *body)
+end
+
+syntax('let-syntax') do |*args|
+  call('let', *args)
+end
+
+syntax('letrec-syntax') do |*args|
+  call('letrec', *args)
+end
+
+#----------------------------------------------------------------
+
+# Iteration
+
+# (do) is similar to the 'while' construct in procedural
+# languages. It assigns initial values to a set of variables,
+# then performs the list of given commands in a loop. If
+# before any iteration the test is found to be false, the
+# loop is halted and the value of the expression following
+# the test is returned.
+syntax('do') do |scope, assignments, test, *commands|
+  closure = Scope.new(scope)
+  assignments.each do |assign|
+    closure[assign.first] = Heist.evaluate(assign[1], scope)
+  end
+  while not Heist.evaluate(test.first, closure)
+    commands.each { |expr| Heist.evaluate(expr, closure) }
+    temp = {}
+    assignments.each do |assign|
+      step = assign[2] || assign[0]
+      temp[assign.first] = Heist.evaluate(step, closure)
+    end
+    assignments.each do |assign|
+      closure[assign.first] = temp[assign.first]
+    end
+  end
+  call('begin', closure, *test.rest)
+end
+
+#----------------------------------------------------------------
+
+# Boolean combinators
+
+# (and) returns the first falsey value returned by the list
+# of expressions, or returns the value of the last expression
+# if all values are truthy.
+syntax('and') do |scope, *args|
+  result = true
+  args.each do |arg|
+    next if not result
+    result = Heist.evaluate(arg, scope)
+  end
+  result
+end
+
+# (or) returns the first truthy value returned by the list
+# of expressions, or returns the value of the last expression
+# if all values are falsey.
+syntax('or') do |scope, *args|
+  result = false
+  args.each do |arg|
+    next if result
+    result = Heist.evaluate(arg, scope)
+  end
+  result
+end
+
+#----------------------------------------------------------------
+
+# Delayed evaluation
+
+# (delay) allows the evaluation of an expression to be delayed
+# by wrapping it in a promise. Use (force) to evaluate the promise
+# at a later time. The expression inside a promise is only
+# ever evaluated once, so a promise can be implemented as a
+# memoized closure.
+syntax('delay') do |scope, expression|
+  promise = Binding.new(expression, scope)
+  Function.new(scope) { promise.extract }
+end
+