heist 0.1.0 → 0.2.0

data/test/numbers.scm

@@ -1,19 +1,41 @@
-(assert (eqv? 42 42))
-(assert (not (eqv? 42 #f)))
-(assert (not (eqv? 42 42.0)))
 (assert (= 42 42))
 (assert (= 42 42.0))
 
 (assert (number? 42))
 (assert (not (number? #t)))
-;(assert (complex? 2+3i))
-;(assert (not (real? 2+3i)))
+(assert (complex? 2+3i))
+(assert (not (real? 2+3i)))
 (assert (real? 3.1416))
 (assert (real? 22/7))
 (assert (real? 42))
-;(assert (not (rational? 2+3i)))
-;(assert (not (rational? 3.1416)))
-;(assert (rational? 22/7))
+(assert (not (rational? 2+3i)))
+(assert (not (rational? 3.1416)))
+(assert (rational? 22/7))
 (assert (not (integer? 22/7)))
 (assert (integer? 42))
 
+(assert (zero? 0))
+(assert (not (zero? 1)))
+(assert (odd? 1))
+(assert (not (odd? 2)))
+(assert (even? 6))
+(assert (not (even? 7)))
+(assert (positive? 5))
+(assert (not (positive? -4)))
+(assert (negative? -13))
+(assert (not (negative? 0)))
+
+(assert-equal 9 (max 8 2 7 3 9 5))
+(assert-equal 2 (min 8 2 7 3 9 5))
+
+(assert (exact? 8))
+(assert (exact? 4/3))
+(assert (exact? 5+3i))
+(assert (inexact? 8.5))
+(assert (inexact? 8.5+4i))
+
+(assert (rational? (/ 4 3)))
+(assert (rational? (/ 4)))
+
+(assert-equal 1 (make-polar 1 0))
+

data/test/test_heist.rb

@@ -13,7 +13,7 @@ Class.new(Test::Unit::TestCase) do
   def setup
     return @@env if @@env
     @@env = Heist::Runtime.new(Heist::BIN_SPEC.parse($args))
-    Heist.info(@@env)
+    puts @@env.info
     
     @@env.define('assert') do |value|
       assert(value)
@@ -21,18 +21,21 @@ Class.new(Test::Unit::TestCase) do
     @@env.define('assert-equal') do |expected, actual|
       assert_equal(expected, actual)
     end
-    @@env.syntax('assert-raise') do |scope, name, expression|
-      exception = Heist.const_get(name.to_s)
-      assert_raise(exception) { @@env.eval(expression) }
+    @@env.syntax('assert-raise') do |scope, cells|
+      exception = Heist.const_get(cells.car.to_s)
+      assert_raise(exception) { scope.eval(cells.cdr.car) }
     end
   end
   
   %w[   booleans
         numbers
+        lists
+        equivalence
         arithmetic
         define_values
         define_functions
         closures
+        functional
         let
         conditionals
         file_loading
@@ -45,6 +48,39 @@ Class.new(Test::Unit::TestCase) do
     end
   end
   
+  def test_cons
+    cons = Heist::Runtime::Cons
+    
+    empty = cons[[]]
+    assert empty.list?
+    assert !empty.pair?
+    assert_equal cons::NULL, empty
+    assert_equal 0, empty.length
+    
+    single = cons[[4]]
+    assert single.list?
+    assert single.pair?
+    assert_equal 1, single.length
+    
+    multi = cons[[2,4,7]]
+    assert multi.list?
+    assert multi.pair?
+    assert_equal 3, multi.length
+    
+    multi.tail.cdr = 8
+    assert multi.pair?
+    assert !multi.list?
+    assert_raise(Heist::TypeError) { multi.size }
+    
+    nested = cons[[2,4,6,cons.new(7,8)]]
+    assert nested.list?
+    assert nested.pair?
+    assert_equal 4, nested.length
+    assert !nested.cdr.cdr.cdr.car.list?
+    assert nested.cdr.cdr.cdr.car.pair?
+    assert_equal 8, nested.cdr.cdr.cdr.car.cdr
+  end
+  
   def test_macro_hygiene
     @@env.run($dir + '/' + (@@env.hygienic? ? 'hygienic' : 'unhygienic'))
   end
@@ -55,14 +91,25 @@ Class.new(Test::Unit::TestCase) do
   end
   
   def test_quotes
-    assert_equal 7, @@env.eval("(+ 3 4)")
-    assert_equal [:+, 3, 4], @@env.eval("'(+ 3 4)").to_a
-    assert Heist::Runtime::List === @@env.eval("'(+ 3 4)")
-    assert_equal 7, @@env.eval("(+ '3 4)")
-    assert_equal [:+, [:-, 7, 9], 4], @@env.eval("'(+ (- 7 9) 4)").to_a
-    assert_equal [7, 9, 6], @@env.eval("`(7 ,(+ 4 5) 6)").to_a
-    assert Heist::Runtime::List === @@env.eval("`(7 ,(+ 4 5) 6)")
-    assert_equal [3, 7, 6, 2, 6, 9], @@env.eval("`(3 7 6 ,@((lambda () '(2 6))) 9)").to_a
+    cons = Heist::Runtime::Cons
+    c = cons.method(:new)
+    
+    assert_equal 7,                     @@env.eval("(+ 3 4)")
+    assert_equal [:+, 3, 4],            @@env.eval("'(+ 3 4)").to_ruby
+    assert cons === @@env.eval("'(+ 3 4)")
+    assert_equal 7,                     @@env.eval("(+ '3 4)")
+    assert_equal c[1,8],                @@env.eval("'(1 . 8)")
+    assert_equal c[1,8],                @@env.eval("`(1 . 8)")
+    assert_equal [:+, [:-, 7, 9], 4],   @@env.eval("'(+ (- 7 9) 4)").to_ruby
+    assert_equal [7, 9, 6],             @@env.eval("`(7 ,(+ 4 5) 6)").to_ruby
+    assert cons === @@env.eval("`(7 ,(+ 4 5) 6)")
+    assert_equal [3, 7, 6, 2, 6, 9],    @@env.eval("`(3 7 6 ,@((lambda () '(2 6))) 9)").to_ruby
+    assert_equal [1, 2, 10],            @@env.eval("`(1 2 ,(+ 4 6))").to_ruby
+    assert_equal [3, 2, 9, 8],          @@env.eval("`(,(/ 9 3) 2 ,@(list 9 8))").to_ruby
+    assert_equal [1, 2, 4, 9, 8, 5],    @@env.eval("`(,@(list 1 2) 4 ,@(list 9 8) 5)").to_ruby
+    assert_equal c[9,c[8,c[5,7]]],      @@env.eval("`(,@(list 9 8) 5 . 7)")
+    assert_equal c[9,c[8,24]],          @@env.eval("`(,@(list 9 8) . ,(* 4 6))")
+    assert_equal [:quote, []],          @@env.eval("''()").to_ruby
   end
   
   def test_birds
@@ -80,5 +127,13 @@ Class.new(Test::Unit::TestCase) do
     
     assert_equal 45, @@env.eval("((K 45) 6)")
   end
+  
+  def test_ruby_execution
+    expr = [[:lambda, [:x], [:+, 1, :x]], 3]
+    assert_equal 4, @@env.exec(expr)
+    list = Heist.parse(expr)
+    assert Heist::Runtime::Cons === list
+    assert_equal expr, list.to_ruby
+  end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: heist
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - James Coglan
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-02-24 00:00:00 +00:00
+date: 2009-04-01 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -57,37 +57,37 @@ extra_rdoc_files:
 files: 
 - History.txt
 - Manifest.txt
-- README.txt
 - Rakefile
+- README.txt
 - bin/heist
-- lib/heist.rb
 - lib/bin_spec.rb
+- lib/heist.rb
 - lib/repl.rb
+- lib/builtin/library.scm
 - lib/builtin/primitives.rb
-- lib/builtin/syntax.rb
 - lib/builtin/syntax.scm
-- lib/builtin/library.scm
-- lib/parser/scheme.tt
-- lib/parser/scheme.rb
 - lib/parser/nodes.rb
-- lib/runtime/runtime.rb
-- lib/runtime/data/expression.rb
-- lib/runtime/data/identifier.rb
-- lib/runtime/data/list.rb
+- lib/parser/ruby.rb
+- lib/parser/scheme.rb
+- lib/parser/scheme.tt
+- lib/runtime/callable/continuation.rb
 - lib/runtime/callable/function.rb
+- lib/runtime/callable/syntax.rb
 - lib/runtime/callable/macro.rb
 - lib/runtime/callable/macro/matches.rb
-- lib/runtime/callable/macro/splice.rb
+- lib/runtime/callable/macro/tree.rb
 - lib/runtime/callable/macro/expansion.rb
-- lib/runtime/callable/continuation.rb
-- lib/runtime/stack.rb
-- lib/runtime/stackless.rb
+- lib/runtime/data/cons.rb
+- lib/runtime/data/expression.rb
+- lib/runtime/data/identifier.rb
+- lib/runtime/binding.rb
 - lib/runtime/frame.rb
+- lib/runtime/runtime.rb
 - lib/runtime/scope.rb
-- lib/runtime/binding.rb
+- lib/runtime/stack.rb
+- lib/runtime/stackless.rb
 - lib/stdlib/benchmark.scm
 - lib/stdlib/birdhouse.scm
-- test/test_heist.rb
 - test/arithmetic.scm
 - test/benchmarks.scm
 - test/booleans.scm
@@ -97,15 +97,19 @@ files:
 - test/define_functions.scm
 - test/define_values.scm
 - test/delay.scm
+- test/equivalence.scm
 - test/file_loading.scm
+- test/functional.scm
+- test/hygienic.scm
 - test/let.scm
 - test/lib.scm
+- test/lists.scm
 - test/macro-helpers.scm
 - test/macros.scm
-- test/hygienic.scm
-- test/unhygienic.scm
-- test/plt-macros.txt
 - test/numbers.scm
+- test/plt-macros.txt
+- test/test_heist.rb
+- test/unhygienic.scm
 - test/vars.scm
 has_rdoc: true
 homepage: Heist is a Scheme interpreter written in Ruby. It provides an executable

data/lib/builtin/syntax.rb

@@ -1,166 +0,0 @@
-# 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
-

data/lib/runtime/callable/macro/splice.rb

@@ -1,56 +0,0 @@
-module Heist
-  class Runtime
-    class Macro
-      
-      class Splice
-        attr_reader :name, :depth
-        
-        def initialize(name, depth)
-          @name, @depth = name, depth
-          @data  = []
-          (0...@depth).inject(@data) { |list, d| list << []; list.last }
-          @indexes = (0..@depth).map { 0 }
-          @stack = []
-        end
-        
-        def <<(value)
-          @stack.pop.call() while not @stack.empty?
-          tail(@depth) << value
-        end
-        
-        def mark!(depth)
-          @stack << lambda { tail(depth) << [] }
-        end
-        
-        def size(depth)
-          current(depth).size
-        end
-        
-        def read
-          current(@depth)[@indexes[@depth]]
-        end
-        
-        def shift!(depth)
-          @indexes[depth] += 1
-          @indexes[depth] = 0 if @indexes[depth] >= current(depth).size
-        end
-        
-        def to_s(depth = 0)
-          "#{@name}#{' ...' * (@depth - depth)}"
-        end
-        
-      private
-        
-        def tail(depth)
-          (0...depth).inject(@data) { |list, d| list.last }
-        end
-        
-        def current(depth)
-          @indexes[0...depth].inject(@data) { |list, i| list[i] }
-        end
-      end
-      
-    end
-  end
-end
-