klam 0.0.1

data/spec/functional/extensions/do_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe 'extension: (do X Y)', :type => :functional do
+  it 'evaluates X before Y' do
+    eval_kl('(set foo "a")')
+    eval_kl('(do (set foo (cn (value foo) "b")) (set foo (cn (value foo) "c")))')
+    expect_kl('(value foo)').to eq("abc")
+  end
+
+  it 'returns the normal form of Y' do
+    expect_kl('(do 37 (+ 40 2))').to eq(42)
+  end
+
+  it 'treats Y as being in tail position' do
+    eval_kl('(defun count-down (X) (if (> X 0) (do ignore-me (count-down (- X 1))) true))')
+    expect_kl('(count-down 20000)').to be(true)
+  end
+
+  it 'allows nesting calls' do
+    expect_kl('(do (+ 1 0) (do (+ 1 1) (+ 1 2)))').to eq(3)
+  end
+end

data/spec/functional/primitives/assignments_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper.rb'
+
+describe 'Assignments primitives', :type => :functional do
+  describe '(set Name Value)' do
+    it 'associates Value with Name' do
+      eval_kl('(set foo bar)')
+      expect_kl('(value foo)').to eq(:bar)
+    end
+
+    it 'returns Value' do
+      expect_kl('(set foo bar)').to eq(:bar)
+    end
+
+    it 'overwrites the previous value when called again with same Name' do
+      eval_kl('(set foo bar)')
+      expect_kl('(set foo baz)').to eq(:baz)
+    end
+
+    it 'does not interfere with the function namespace' do
+      eval_kl('(set value bar)')
+      expect_kl('(value value)').to eq(:bar)
+    end
+  end
+
+  describe '(value Name)' do
+    # Duplicated for documentation purposes
+    it 'returns the value associated with Name' do
+      eval_kl('(set foo bar)')
+      expect_kl('(value foo)').to eq(:bar)
+    end
+
+    it 'raises an error if Name has not previously been set' do
+      expect {
+        eval_kl('(value an-unset-symobl)')
+      }.to raise_error(Klam::Error)
+    end
+  end
+end

data/spec/functional/primitives/boolean_operations_spec.rb

@@ -0,0 +1,133 @@
+require 'spec_helper'
+
+describe 'Boolean operation primitives', :type => :functional do
+  describe '(and Expr1 Expr2)' do
+    describe 'when Expr1 evaluates to true' do
+      it 'returns the result of evaluating Expr2' do
+        expect_kl('(and (< 1 2) (> 3 3))').to be(false)
+        expect_kl('(and (< 1 2) (>= 3 3))').to be(true)
+      end
+    end
+
+    describe 'when Expr1 evaluates to false' do
+      it 'returns false' do
+        expect_kl('(and (> 1 2) true)').to be(false)
+      end
+
+      it 'does not evaluate Expr2' do
+        eval_kl('(set success true)')
+        eval_kl('(and (> 1 2) (set success false))')
+        expect_kl('(value success)').to be(true)
+      end
+    end
+
+    it 'is available for partial application' do
+      expect_kl('((and true) true)').to be(true)
+    end
+  end
+
+  describe '(cond Test1 Expr1 ... TestN ExprN)' do
+    it 'returns the normal form of the Expr for the first true Test' do
+      kl = <<-EOKL
+        (cond
+          ((< 3 3) 1)
+          ((= 3 3) 2)
+          ((= 1 1) 3))
+      EOKL
+
+      expect_kl(kl).to eq(2)
+    end
+
+    it 'does not evaluate the other Exprs' do
+      eval_kl('(set expr1-was-evaluated false)')
+      eval_kl('(set expr2-was-evaluated false)')
+      eval_kl('(set expr3-was-evaluated false)')
+
+      kl = <<-EOKL
+        (cond
+          ((< 3 3) (set expr1-was-evaluated true))
+          ((<= 3 3) (set expr2-was-evaluated true))
+          ((<= 1 1) (set expr3-was-evaluated true)))
+      EOKL
+      eval_kl(kl)
+
+      expect_kl('(value expr1-was-evaluated)').to be(false)
+      expect_kl('(value expr2-was-evaluated)').to be(true)
+      expect_kl('(value expr3-was-evaluated)').to be(false)
+    end
+
+    it 'does not evaluate the subsequent tests' do
+      eval_kl('(set test3-was-evaluated false)')
+
+      kl = <<-EOKL
+        (cond
+          ((< 3 3) 1)
+          ((<= 3 3) 2)
+          ((set test3-was-evaluated true) 3))
+      EOKL
+      eval_kl(kl)
+
+      expect_kl('(value test3-was-evaluated)').to be(false)
+    end
+
+    it 'raises an error if none of the tests evaluate to true' do
+      expect_kl('(trap-error (cond (false false)) error-to-string)')
+        .to eq('cond failure')
+    end
+  end
+
+  describe '(if Test TrueExpr FalseExpr)' do
+    describe 'when Test evaluates to true' do
+      it 'returns the value of TrueExpr' do
+        expect_kl('(if (< 1 2) yes no)').to eq(:yes)
+      end
+
+      it 'does not evaluate FalseExpr' do
+        eval_kl('(set success true)')
+        eval_kl('(if (< 1 2) yes (set success false))')
+        expect_kl('(value success)').to be(true)
+      end
+    end
+
+    describe 'when Test evaluates to false' do
+      it 'returns the value of FalseExpr' do
+        expect_kl('(if (> 1 2) yes no)').to eq(:no)
+      end
+
+      it 'does not evaluate TrueExpr' do
+        eval_kl('(set success true)')
+        eval_kl('(if (> 1 2) (set success false) no)')
+        expect_kl('(value success)').to be(true)
+      end
+    end
+
+    it 'is available for partial application' do
+      expect_kl('(((if false) 1) 37)').to eq(37)
+    end
+  end
+
+  describe '(or Expr1 Expr2)' do
+    describe 'when Expr1 evaluates to true' do
+      it 'returns true' do
+        expect_kl('(or (< 1 2) false)').to be(true)
+      end
+
+      it 'does not evaluate Expr2' do
+        eval_kl('(set success true)')
+        eval_kl('(or (< 1 2) (set success false))')
+        expect_kl('(value success)').to be(true)
+      end
+    end
+
+    describe 'when Expr1 evaluates to false' do
+      it 'returns the result of evaluating Expr2' do
+        expect_kl('(or (> 1 2) (> 3 3))').to be(false)
+        expect_kl('(or (> 1 2) (>= 3 3))').to be(true)
+      end
+    end
+
+    it 'is available for partial application' do
+      expect_kl('((or false) false)').to be(false)
+    end
+  end
+end

data/spec/functional/primitives/error_handling_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe 'Error handling primitives', :type => :functional do
+  describe '(trap-error Expr Handler)' do
+    describe 'when evaluating Expr succeeds' do
+      it 'returns the normal form of Expr' do
+        expect_kl('(trap-error (+ 1 2) error-to-string)').to eq(3)
+      end
+    end
+
+    describe 'when evaluating Expr raises an error' do
+      it 'applies Handler to the error' do
+        expect_kl('(trap-error (simple-error "oops!") error-to-string)')
+          .to eq('oops!')
+      end
+    end
+
+    it 'may be used as an argument to another function' do
+      expect_kl('(+ (trap-error 2 error-to-string) 3)').to eq(5)
+    end
+  end
+end

data/spec/functional/primitives/generic_functions_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe 'Generic function primitives', :type => :functional do
+  describe '(defun Name Params Expr)' do
+    it 'returns Name' do
+      expect_kl('(defun foo (X) X)').to eq(:foo)
+    end
+
+    it 'does not evaluate Expr' do
+      eval_kl('(set success true)')
+      eval_kl('(defun foo (X) (set success false))')
+      expect_kl('(value success)').to be(true)
+    end
+
+    it 'installs Name as a global function' do
+      eval_kl('(defun foo (X) X)')
+      expect_kl('(foo 37)').to eq(37)
+    end
+
+    it 'allows names that are not allowed with the Ruby define syntax' do
+      eval_kl('(defun f-o-o (X) X)')
+      expect_kl('(f-o-o 37)').to eq(37)
+    end
+
+    it 'allows parameter names that are not valid Ruby parameter names' do
+      eval_kl('(defun foo (A!B?-C) A!B?-C)')
+      expect_kl('(foo 37)').to eq(37)
+    end
+
+    it 'allows params to be empty' do
+      eval_kl('(defun foo () 37)')
+      expect_kl('(foo)').to eq(37)
+    end
+  end
+
+  describe '(lambda Var Expr)' do
+    it 'returns a function' do
+      expect_kl('(lambda X X)').to be_kind_of(Proc)
+    end
+
+    it 'does not evaluate Expr' do
+      eval_kl('(set success true)')
+      eval_kl('(lambda X (set success false))')
+      expect_kl('(value success)').to be(true)
+    end
+  end
+
+  describe '(let Var ValueExpr BodyExpr)' do
+    it 'evaluates BodyExpr with Var bound to the normal form of ValueExpr' do
+      expect_kl('(let X (+ 1 2) (* X 2))').to eq(6)
+    end
+
+    it 'uses the inner-most binding when Var is shadowed' do
+      expect_kl('(let X 1 (let X 2 X))').to eq(2)
+    end
+  end
+
+  describe '(freeze Expr)' do
+    it 'returns a function' do
+      expect_kl('(freeze (+ 30 7))').to be_kind_of(Proc)
+    end
+
+    it 'does not evaluate Expr' do
+      eval_kl('(set success true)')
+      eval_kl('(freeze (set success false))')
+      expect_kl('(value success)').to be(true)
+    end
+
+    describe 'when thawed' do
+      it 'evaluates the frozen Expr and returns the result' do
+        eval_kl('(defun thaw (Thunk) (Thunk))')
+        expect_kl('(thaw (freeze (+ 30 7)))').to eq(37)
+      end
+    end
+  end
+
+  describe '(type Expr Type)' do
+    it 'returns the normal form of Expr' do
+      expect_kl('(type (+ 1 2) expr)').to eq(3)
+    end
+  end
+end

data/spec/functional/tail_call_optimization_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+describe 'Tail call optimization', :type => :functional do
+  it 'optimizes self tail calls in an if true clause' do
+    eval_kl('(defun count-down (X) (if (> X 0) (count-down (- X 1)) true))')
+    expect_kl('(count-down 20000)').to be(true)
+  end
+
+  it 'optimizes self tail calls in an if false clause' do
+    eval_kl('(defun count-down (X) (if (<= X 0) true (count-down (- X 1))))')
+    expect_kl('(count-down 20000)').to be(true)
+  end
+
+  it 'optimizes self tail calls in a let body' do
+    eval_kl('(defun count-down (X) (if (<= X 0) true (let F 1 (count-down (- X 1)))))')
+    expect_kl('(count-down 20000)').to be(true)
+  end
+
+  it 'uses the current values of the params when calculating the new ones' do
+    eval_kl <<-EOKL
+      (defun fact-iter (N Accum)
+        (if (= N 1)
+          Accum
+          (fact-iter (- N 1) (* N Accum))))
+    EOKL
+    expect_kl('(fact-iter 5 1)').to eq(120)
+  end
+
+  it 'preserves the value of closed-over function parameters' do
+    eval_kl('(set foo (absvector 3))')
+    eval_kl <<-EOKL
+      (defun do-it (N)
+        (if (= N 3)
+          true
+          (let _ (address-> (value foo) N (freeze N))
+               (do-it (+ N 1)))))
+    EOKL
+    eval_kl('(do-it 0)')
+    expect_kl('((<-address (value foo) 0))').to eq(0)
+    expect_kl('((<-address (value foo) 1))').to eq(1)
+    expect_kl('((<-address (value foo) 2))').to eq(2)
+  end
+
+  it 'preserves the value of closed-over local variables' do
+    eval_kl('(set foo (absvector 3))')
+    eval_kl <<-EOKL
+      (defun do-it (N)
+        (if (= N 3)
+          true
+          (let X N
+               (let _ (address-> (value foo) N (freeze X))
+                    (do-it (+ N 1))))))
+    EOKL
+    eval_kl('(do-it 0)')
+    expect_kl('((<-address (value foo) 0))').to eq(0)
+    expect_kl('((<-address (value foo) 1))').to eq(1)
+    expect_kl('((<-address (value foo) 2))').to eq(2)
+  end
+
+  it 'supports functions with zero arguments' do
+    eval_kl('(set counter 0)')
+    eval_kl <<-EOKL
+      (defun count-down ()
+        (if (= 20000 (set counter (+ (value counter) 1)))
+          true
+          (count-down)))
+    EOKL
+    expect_kl('(count-down)').to be(true)
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,27 @@
+require 'stringio'
+require 'klam'
+
+module EvalKl
+  def read_kl(str)
+    stream = StringIO.new(str)
+    reader = Klam::Reader.new(stream)
+    reader.next
+  end
+
+  def eval_kl(str)
+    form = read_kl(str)
+    @env.__send__(:"eval-kl", form)
+  end
+
+  def expect_kl(str)
+    expect(eval_kl(str))
+  end
+end
+
+RSpec.configure do |cfg|
+  # Support eval_kl and friends in functional specs
+  cfg.include EvalKl, :type => :functional
+  cfg.before(:each, :type => :functional) do
+    @env = Klam::Environment.new
+  end
+end

data/spec/unit/klam/compilation_stages/convert_lexical_variables_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe Klam::CompilationStages::ConvertLexicalVariables do
+  include Klam::CompilationStages::ConvertLexicalVariables
+
+  # ConvertLexicalVariables requires this function to be defined
+  # by its including class.
+  def fresh_variable
+    @generator.next
+  end
+
+  def reset_generator
+    @generator = Klam::VariableGenerator.new
+  end
+
+  before(:each) do
+    reset_generator
+  end
+
+  describe 'with defun' do
+    it 'converts formal param symbols to variables' do
+      sexp = [:defun, :foo, [:X, :Y], [:+, :X, :Y]]
+      converted = convert_lexical_variables(sexp)
+
+      reset_generator
+      v1, v2 = fresh_variable, fresh_variable
+      expected = [:defun, :foo, [v1, v2], [:+, v1, v2]]
+
+      expect(converted).to eq(expected)
+    end
+  end
+
+  describe 'with lambda' do
+    it 'converts formal param symbols to variables' do
+      sexp = [:lambda, [:X, :Y], [:+, :X, :Y]]
+      converted = convert_lexical_variables(sexp)
+
+      reset_generator
+      v1, v2 = fresh_variable, fresh_variable
+      expected = [:lambda, [v1, v2], [:+, v1, v2]]
+
+      expect(converted).to eq(expected)
+    end
+  end
+
+  describe 'with let' do
+    it 'converts var param to a variable' do
+      sexp = [:let, :X, [:+, :X, 1], [:+, :X, 2]]
+      converted = convert_lexical_variables(sexp)
+
+      reset_generator
+      v1 = fresh_variable
+      expected = [:let, v1, [:+, :X, 1], [:+, v1, 2]]
+
+      expect(converted).to eq(expected)
+    end
+  end
+end