klam 0.0.1

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

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Klam::CompilationStages::ConvertSelfTailCallsToLoops do
+  include Klam::CompilationStages::ConvertSelfTailCallsToLoops
+  it 'converts self tail calls to loop/recur' do
+    # For simplicity the vars below are symbols, but will be
+    # Klam::Variables in practice. They do not come into play for
+    # the conversion, though.
+    expr = [:defun, :f, [:X, :Y],
+             [:if, true,
+               [:f, 7, 8],
+               [:let, :Z, 37,
+                 [:f, :Z, 99]]]]
+    expected = [:defun, :f, [:X, :Y],
+                 [:"[LOOP]", :f, [:X, :Y],
+                   [:if, true,
+                     [:"[RECUR]", [:X, :Y], [7, 8]],
+                     [:let, :Z, 37,
+                      [:"[RECUR]", [:X, :Y], [:Z, 99]]]]]]
+
+    expect(convert_self_tail_calls_to_loops(expr)).to eq(expected)
+  end
+
+  it 'does not convert partial calls' do
+    expr = [:defun, :f, [:X, :Y],
+             [:f, :X]]
+    expected = [:defun, :f, [:X, :Y],
+                 [:"[LOOP]", :f, [:X, :Y],
+                   [:f, :X]]]
+
+    expect(convert_self_tail_calls_to_loops(expr)).to eq(expected)
+  end
+end

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

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Klam::CompilationStages::CurryAbstractionApplications do
+  include Klam::CompilationStages::CurryAbstractionApplications
+  it 'converts to applying one argument at a time' do
+    expr = [[:foo], 1, 2, 3]
+    expected = [[[[:foo], 1], 2], 3]
+
+    expect(curry_abstraction_applications(expr)).to eq(expected)
+  end
+
+  it 'converts variable application to curried form' do
+    var = Klam::Variable.new('foo')
+    expr = [var, 1, 2, 3]
+    expected = [[[var, 1], 2], 3]
+
+    expect(curry_abstraction_applications(expr)).to eq(expected)
+  end
+end

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

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Klam::CompilationStages::MakeAbstractionsVariadic do
+  include Klam::CompilationStages::MakeAbstractionsVariadic
+
+  it 'converts the single Kl lambda param to a one-element list' do
+    expr = [:lambda, :X, [:lambda, :Y, [:+, :X, :Y]]]
+    expected = [:lambda, [:X], [:lambda, [:Y], [:+, :X, :Y]]]
+
+    expect(make_abstractions_variadic(expr)).to eq(expected)
+  end
+end

data/spec/unit/klam/converters/list_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe Klam::Converters::List do
+  include Klam::Converters::List
+
+  before(:each) do
+    @empty_list = Klam::Primitives::Lists::EMPTY_LIST
+  end
+
+  describe '.arrayToList' do
+    it 'returns the empty list when given an empty array' do
+      expect(arrayToList([])).to be @empty_list
+    end
+
+    it 'handles nested empty lists' do
+      expect(arrayToList([[]])).to eq(cons(@empty_list, @empty_list))
+    end
+
+    it 'returns the corresponding list for a non-empty array' do
+      expect(arrayToList([1, 2])).to eq(cons(1, cons(2, @empty_list)))
+    end
+
+    it 'recursively converts nested arrays to nested lists' do
+      array1 = [1, 2]
+      list1 = arrayToList(array1)
+      array2 = [:a, :b, :c]
+      list2 = arrayToList(array2)
+
+      expect(arrayToList([array1, array2]))
+        .to eq(cons(list1, cons(list2, @empty_list)))
+    end
+  end
+
+  describe '.listToArray' do
+    it 'returns an empty array when given the empty list' do
+      expect(listToArray(@empty_list)).to eq([])
+    end
+
+    it 'handles nested empty lists' do
+      expect(listToArray(cons(@empty_list, @empty_list))).to eq([[]])
+    end
+
+    it 'returns the corresponding array for a non-emtpy list' do
+      expect(listToArray(cons(1, cons(2, @empty_list)))).to eq([1, 2])
+    end
+
+    it 'recursively converts nested lists to nested arrays' do
+      list1 = cons(1, cons(2, @empty_list))
+      array1 = listToArray(list1)
+      list2 = cons(:a, cons(:b, cons(:c, @empty_list)))
+      array2 = listToArray(list2)
+
+      expect(listToArray(cons(list1, cons(list2, @empty_list))))
+        .to eq([array1, array2])
+    end
+  end
+end

data/spec/unit/klam/lexer_spec.rb

@@ -0,0 +1,149 @@
+require 'spec_helper'
+
+describe Klam::Lexer do
+  def lexer(str)
+    Klam::Lexer.new(StringIO.new(str))
+  end
+
+  describe 'syntax tokens' do
+    it 'reads ( as a Klam::Lexer::OpenParen' do
+      expect(lexer("(").next).to be_kind_of(Klam::Lexer::OpenParen)
+    end
+
+    it 'reads ) as a Klam::Lexer::CloseParen' do
+      expect(lexer(")").next).to be_kind_of(Klam::Lexer::CloseParen)
+    end
+  end
+
+  describe 'string tokens' do
+    it 'reads double-quoted strings' do
+      expect(lexer('"Fred"').next).to eq("Fred")
+    end
+
+    it 'throws Klam::SyntaxError on unterminated strings' do
+      expect {
+        lexer('"Fred').next
+      }.to raise_error(Klam::SyntaxError, "unterminated string")
+    end
+  end
+
+  describe 'symbols' do
+    it 'reads sign characters not followed by digits as symbols' do
+      expect(lexer('-').next).to eq('-'.to_sym)
+      expect(lexer('+').next).to eq('+'.to_sym)
+      expect(lexer('--+-').next).to eq('--+-'.to_sym)
+    end
+
+    it 'reads double decimal points followed by digits as symbols' do
+      expect(lexer('..77').next).to eq('..77'.to_sym)
+    end
+
+    it "accepts =-*/+_?$!@~><&%'#`;:{} in symbols" do
+      all_punctuation = "=-*/+_?$!@~><&%'#`;:{}"
+      sym = lexer(all_punctuation).next
+      expect(sym).to be_kind_of(Symbol)
+      expect(sym.to_s).to eq(all_punctuation)
+    end
+  end
+
+  describe 'numbers' do
+    it 'reads integers as Fixnums' do
+      num = lexer("37").next
+      expect(num).to be_kind_of(Fixnum)
+      expect(num).to eq(37)
+    end
+
+    it 'reads floating points as Floats' do
+      num = lexer("37.42").next
+      expect(num).to be_kind_of(Float)
+      expect(num).to eq(37.42)
+    end
+
+    it 'with an odd number of leading minuses are negative' do
+      expect(lexer('-1').next).to eq(-1)
+      expect(lexer('---1').next).to eq(-1)
+    end
+
+    it 'with an even number of leading minuses are positive' do
+      expect(lexer('--1').next).to eq(1)
+      expect(lexer('----1').next).to eq(1)
+    end
+
+    it 'with leading + does not change sign' do
+      expect(lexer('+-1').next).to eq(-1)
+      expect(lexer('-+--1').next).to eq(-1)
+      expect(lexer('-+-+1').next).to eq(1)
+      expect(lexer('+-+-+-+-+1').next).to eq(1)
+    end
+
+    it 'allows leading decimal points' do
+      expect(lexer('.9').next).to eq(0.9)
+      expect(lexer('-.9').next).to eq(-0.9)
+    end
+
+    it 'treats a trailing decimal followed by EOF as a symbol' do
+      l = lexer('7.')
+      num = l.next
+      expect(num).to be_kind_of(Fixnum)
+      expect(num).to eq(7)
+
+      sym = l.next
+      expect(sym).to be_kind_of(Symbol)
+      expect(sym.to_s).to eq('.')
+    end
+
+    it 'treats a trailing decimal followed by non-digit as a symbol' do
+      l = lexer('7.a')
+      num = l.next
+      expect(num).to be_kind_of(Fixnum)
+      expect(num).to eq(7)
+
+      sym = l.next
+      expect(sym).to be_kind_of(Symbol)
+      expect(sym.to_s).to eq('.a')
+    end
+
+    it 'handles multiple decimal points like shen does' do
+      l = lexer('7.8.9')
+      expect(l.next).to eq(7.8)
+      expect(l.next).to eq(0.9)
+    end
+  end
+
+  describe 'booleans' do
+    it 'reads true as boolean true' do
+      expect(lexer('true').next).to be_kind_of(TrueClass)
+    end
+
+    it 'reads false as boolean false' do
+      expect(lexer('false').next).to be_kind_of(FalseClass)
+    end
+  end
+
+  describe 'whitespace' do
+    it 'is ignored between tokens' do
+      l = lexer("     (\n\t)   ")
+      expect(l.next).to be_kind_of(Klam::Lexer::OpenParen)
+      expect(l.next).to be_kind_of(Klam::Lexer::CloseParen)
+      expect(l.next).to be_nil
+    end
+
+    it 'is left intact in strings' do
+      expect(lexer('     "one two"   ').next).to eq("one two")
+    end
+  end
+
+  it 'works with these all together' do
+    l = lexer('(12 quick m-*$ RAN `fast\' -.7) "oh 12 yeah!"  ')
+    expect(l.next).to be_kind_of(Klam::Lexer::OpenParen)
+    expect(l.next).to eq(12)
+    expect(l.next).to eq(:quick)
+    expect(l.next).to eq('m-*$'.to_sym)
+    expect(l.next).to eq(:RAN)
+    expect(l.next).to eq("`fast'".to_sym)
+    expect(l.next).to eq(-0.7)
+    expect(l.next).to be_kind_of(Klam::Lexer::CloseParen)
+    expect(l.next).to eq("oh 12 yeah!")
+    expect(l.next).to be_nil
+  end
+end

data/spec/unit/klam/primitives/arithmetic_spec.rb

@@ -0,0 +1,153 @@
+require 'spec_helper'
+
+describe Klam::Primitives::Arithmetic do
+  include Klam::Primitives::Arithmetic
+
+  describe '+' do
+    it 'adds its first argument to its second' do
+      expect(send(:+, 1, 2)).to be(3)
+    end
+
+    it 'returns an integer when both arguments are integers' do
+      expect(send(:+, 1, 2)).to be_kind_of(Fixnum)
+    end
+
+    it 'returns a real when either arguments are reals' do
+      real_first = send(:+, 1.1, 2)
+      real_second = send(:+, 1, 2.1)
+      real_both = send(:+, 1.1, 2.1)
+      types = [real_first, real_second, real_both].map(&:class)
+
+      expect(types.uniq).to eq([Float])
+    end
+  end
+
+  describe '-' do
+    it 'subtracts its second argument from its second' do
+      expect(send(:-, 1, 2)).to be(-1)
+    end
+
+    it 'returns an integer when both arguments are integers' do
+      expect(send(:-, 1, 2)).to be_kind_of(Fixnum)
+    end
+
+    it 'returns a real when either arguments are reals' do
+      real_first = send(:-, 1.1, 2)
+      real_second = send(:-, 1, 2.1)
+      real_both = send(:-, 1.1, 2.1)
+      types = [real_first, real_second, real_both].map(&:class)
+
+      expect(types.uniq).to eq([Float])
+    end
+  end
+
+  describe '*' do
+    it 'multiplies its first argument by its second' do
+      expect(send(:*, 2, 3)).to be(6)
+    end
+
+    it 'returns an integer when both arguments are integers' do
+      expect(send(:*, 1, 2)).to be_kind_of(Fixnum)
+    end
+
+    it 'returns a real when either arguments are reals' do
+      real_first = send(:*, 1.1, 2)
+      real_second = send(:*, 1, 2.1)
+      real_both = send(:*, 1.1, 2.1)
+      types = [real_first, real_second, real_both].map(&:class)
+
+      expect(types.uniq).to eq([Float])
+    end
+  end
+
+  describe '/' do
+    it 'divides its first argument by its second' do
+      expect(send(:/, 6, 3)).to be(2)
+    end
+
+    it 'returns an integer when both arguments are integers and there is no remainder' do
+      expect(send(:/, 6, 2)).to be_kind_of(Fixnum)
+    end
+
+    it 'returns a real otherwise' do
+      real_first = send(:/, 1.1, 2)
+      real_second = send(:/, 1, 2.1)
+      real_both = send(:/, 1.1, 2.1)
+      having_remainder = send(:/, 3, 2)
+      types = [real_first, real_second, real_both, having_remainder]
+        .map(&:class)
+
+      expect(types.uniq).to eq([Float])
+    end
+  end
+
+  describe '<' do
+    it 'returns true is the first argument is less than the second' do
+      expect(send(:<, 1, 2)).to be(true)
+    end
+
+    it 'returns false if the first argument is equal to the second' do
+      expect(send(:<, 2, 2)).to be(false)
+    end
+
+    it 'returns false if the first argument is greater than the second' do
+      expect(send(:<, 3, 2)).to be(false)
+    end
+  end
+
+  describe '>' do
+    it 'returns false is the first argument is less than the second' do
+      expect(send(:>, 1, 2)).to be(false)
+    end
+
+    it 'returns false if the first argument is equal to the second' do
+      expect(send(:>, 2, 2)).to be(false)
+    end
+
+    it 'returns true if the first argument is greater than the second' do
+      expect(send(:>, 3, 2)).to be(true)
+    end
+  end
+
+  describe '<=' do
+    it 'returns true is the first argument is less than the second' do
+      expect(send(:<=, 1, 2)).to be(true)
+    end
+
+    it 'returns true if the first argument is equal to the second' do
+      expect(send(:<=, 2, 2)).to be(true)
+    end
+
+    it 'returns false if the first argument is greater than the second' do
+      expect(send(:<=, 3, 2)).to be(false)
+    end
+  end
+
+  describe '>=' do
+    it 'returns false is the first argument is less than the second' do
+      expect(send(:>=, 1, 2)).to be(false)
+    end
+
+    it 'returns true if the first argument is equal to the second' do
+      expect(send(:>=, 2, 2)).to be(true)
+    end
+
+    it 'returns true if the first argument is greater than the second' do
+      expect(send(:>=, 3, 2)).to be(true)
+    end
+  end
+
+  describe 'number?' do
+    it 'returns true for integers' do
+      expect(number?(1)).to be(true)
+    end
+
+    it 'returns true for reals' do
+      expect(number?(1.1)).to be(true)
+    end
+
+    it 'returns false otherwise' do
+      expect(number?('hi')).to be(false)
+    end
+  end
+end

data/spec/unit/klam/primitives/boolean_operations_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe Klam::Primitives::BooleanOperations do
+  include Klam::Primitives::BooleanOperations
+
+  describe '(if TestVal TrueVal FalseVal)' do
+    it 'returns TrueVal if TestVal is true' do
+      expect(send(:if, true, :foo, :bar)).to eq(:foo)
+    end
+
+    it 'returns FalseVal if TestVal is false' do
+      expect(send(:if, false, :foo, :bar)).to eq(:bar)
+    end
+  end
+
+  describe '(and A B)' do
+    it 'returns true when both A and B are true' do
+      expect(send(:and, true, true)).to be(true)
+    end
+
+    it 'returns false otherwise' do
+      expect(send(:and, false, true)).to be(false)
+      expect(send(:and, true, false)).to be(false)
+      expect(send(:and, false, false)).to be(false)
+    end
+  end
+
+  describe '(or A B)' do
+    it 'returns false when both A and B are false' do
+      expect(send(:or, false, false)).to be(false)
+    end
+
+    it 'returns true otherwise' do
+      expect(send(:or, false, true)).to be(true)
+      expect(send(:or, true, false)).to be(true)
+      expect(send(:or, true, true)).to be(true)
+    end
+  end
+end