skeem 0.1.03 → 0.2.00

data/spec/skeem/lambda_spec.rb

@@ -0,0 +1,114 @@
+require_relative '../spec_helper' # Use the RSpec framework
+
+# Load the class under test
+require_relative '../../lib/skeem/interpreter'
+
+module Skeem
+  describe 'The interpreter and compound procedures' do
+    subject do
+      # We load the interpreter with the primitive procedures only
+      Interpreter.new { |interp| interp.add_primitives(interp.runtime) }
+    end
+
+    let(:definition_set) do
+      source = <<-SKEEM
+  (define square
+    (lambda (x)
+      (* x x)))
+
+  (define sum-of-squares
+    (lambda (x y)
+      (+ (square x) (square y))))
+
+  (define f
+    (lambda (a)
+      (sum-of-squares (+ a 1) (* a 2))))
+SKEEM
+      source
+    end
+
+    context 'Defining compound procedures:' do
+      it 'should accept the definition of simple procedure with arity 1' do
+        source = definition_set + "\n" + 'square'
+        result = subject.run(source)
+
+        square = result.last
+        expect(square).to be_kind_of(SkmLambda)
+        expect(square.arity).to eq(1)
+        expect(square.environment).to eq(subject.runtime.environment)
+      end
+
+      it 'should accept the definition of simple procedure with arity 2' do
+        source = definition_set + "\n" + 'sum-of-squares'
+        result = subject.run(source)
+
+        square = result.last
+        expect(square).to be_kind_of(SkmLambda)
+        expect(square.arity).to eq(2)
+        expect(square.environment).to eq(subject.runtime.environment)
+      end
+    end # context
+
+    context 'Calling compound procedures:' do
+      it 'should support the call to a simple procedure with arity 1' do
+        # Case 1: argument is a simple datum
+        subject.run(definition_set)
+        result = subject.run('(square 2)')
+        expect(result).to eq(4)
+
+        # Case 2: argument is a sub-expression
+        ptree = subject.parse('(square (+ 2 1))')
+        proc_call = ptree.root
+        expect(proc_call.evaluate(subject.runtime)).to eq(9)
+      end
+
+      it 'should support the call to a simple procedure with arity 2' do
+        source = definition_set + "\n" + '(sum-of-squares 3 4)'
+        result = subject.run(source)
+
+        expect(result.last).to eq(25)
+      end
+
+      it 'should support the call to a nested lambda procedure' do
+        source = definition_set + "\n" + '(f 5)'
+        result = subject.run(source)
+
+        expect(result.last).to eq(136)
+      end
+      
+      it 'should accept calls to anonymous procedures' do
+        source = '((lambda (x) (+ x x)) 4)'
+        result = subject.run(source)
+        expect(result).to eq(8)
+      end
+      
+      it 'should accept unary second-order lambdas' do
+        source = <<-SKEEM
+  (define add-with
+    (lambda (x) (lambda (y) (+ x y)))
+  )
+  (define add4 (add-with 4))
+SKEEM
+        subject.run(source)
+        result = subject.run('(add4 3)')
+        expect(result).to eq(7)
+      end
+    end # context
+      
+    context 'More advanced features:' do
+      subject { Interpreter.new }
+    
+      it 'should implement binary second-order functions' do
+        source = <<-SKEEM
+  (define compose
+    (lambda (f g)
+      (lambda (x)
+        (f (g x)))))
+SKEEM
+        result = subject.run(source)
+        result = subject.run('((compose list square) 5)')
+        expect(result.last).to eq(25)
+      end       
+    end # context
+  end # describe
+end # module

data/spec/skeem/primitive/primitive_builder_spec.rb

@@ -6,7 +6,10 @@ require_relative '../../../lib/skeem/interpreter'
 module Skeem
   module Primitive
     describe 'Testing primitive procedures' do
-      subject { Interpreter.new }
+      subject do
+        # We load the interpreter with the primitive procedures only
+        Interpreter.new { |interp| interp.add_primitives(interp.runtime) }
+      end
 
       context 'Arithmetic operators:' do
         it 'should implement the set! form' do
@@ -16,6 +19,7 @@ module Skeem
 SKEEM
           result = subject.run(skeem1)
           expect(result.last).to eq(3)  # x is bound to value 2
+
           skeem2 = <<-SKEEM
   (set! x 4)
   (+ x 1)
@@ -448,8 +452,8 @@ SKEEM
             ['(list? #f)', false],
             ['(list? 1)', false],
             ['(list? "bar")', false],
-            ['(list? (list 1 2 3))', true],
-            ['(list? (list))', true]
+            ["(list? '(1 2 3))", true],
+            ["(list? '())", true]
           ]
           checks.each do |(skeem_expr, expectation)|
             result = subject.run(skeem_expr)
@@ -464,8 +468,8 @@ SKEEM
             ['(null? 0)', false],
             ['(null? "bar")', false],
             ['(null? "")', false],
-            ['(null? (list 1 2 3))', false],
-            ['(list? (list))', true]
+            ["(null? '(1 2 3))", false],
+            ["(list? '())", true]
           ]
           checks.each do |(skeem_expr, expectation)|
             result = subject.run(skeem_expr)
@@ -548,10 +552,10 @@ SKEEM
 
         it 'should implement the length procedure' do
           checks = [
-            ['(length (list))', 0],
-            ['(length (list 1))', 1],
-            ['(length (list 1 2))', 2],
-            ['(length (list 1 2 3))', 3]
+            ["(length '())", 0],
+            ["(length '(1))", 1],
+            ["(length '(1 2))", 2],
+            ["(length '(1 2 3))", 3]
           ]
           checks.each do |(skeem_expr, expectation)|
             result = subject.run(skeem_expr)
@@ -597,7 +601,7 @@ SKEEM
             ['(vector? #f)', false],
             ['(vector? 1)', false],
             ['(vector? "bar")', false],
-            ['(vector? (list 1 2 3))', false],
+            ["(vector? '(1 2 3))", false],
             ['(vector? #(1 #f "cool"))', true]
           ]
           checks.each do |(skeem_expr, expectation)|
@@ -680,7 +684,7 @@ SKEEM
           source = <<-SKEEM
   (define x 2)
   (define y 1)
-  (assert (> x y))
+  (test-assert (> x y))
 SKEEM
           expect(subject.run(source).last).to eq(true)
         end
@@ -689,7 +693,7 @@ SKEEM
           source = <<-SKEEM
   (define x 1)
   (define y 2)
-  (assert (> x y))
+  (test-assert (> x y))
 SKEEM
           err = StandardError
           msg = 'Error: assertion failed on line 3, column 4'

data/spec/skeem/primitive/primitive_procedure_spec.rb

@@ -6,10 +6,6 @@ require_relative '../../../lib/skeem/primitive/primitive_procedure'
 module Skeem
   module Primitive
     describe PrimitiveProcedure do
-      def call_proc(aName, args)
-        ProcedureCall.new(nil, aName, args)
-      end
-
       let(:nullary) { SkmArity.new(0, 0) }
       let(:unary) { SkmArity.new(1, 1) }
       let(:binary) { SkmArity.new(2, 2) }
@@ -93,30 +89,27 @@ module Skeem
           pproc = PrimitiveProcedure.new('newline', nullary, newline_code)
           rtime = double('fake-runtime')
 
-          invokation = call_proc('newline', nil)
-          expect(pproc.call(rtime, invokation)).to eq("\n")
+          expect(pproc.call(rtime, [])).to eq("\n")
 
-          too_much = call_proc('newline', ['superfluous'])
           err = StandardError
           ms1 = 'Wrong number of arguments for #<Procedure newline>'
           ms2 = ' (required at least 0, got 1)'
-          expect { pproc.call(rtime, too_much) }.to raise_error(err, ms1 + ms2)
+          expect { pproc.call(rtime, ['superfluous']) }.to raise_error(err, ms1 + ms2)
         end
 
         it 'should support Skeem unary procedure' do
           pproc = PrimitiveProcedure.new('cube', unary, cube)
           rtime = double('fake-runtime')
 
-          invokation = call_proc('cube', [SkmInteger.create(3)])
-          expect(pproc.call(rtime, invokation)).to eq(27)
+          args = [SkmInteger.create(3)]
+          expect(pproc.call(rtime, args)).to eq(27)
 
-          too_few = call_proc('cube', nil)
           err = StandardError
           ms1 = 'Wrong number of arguments for #<Procedure cube>'
           ms2 = ' (required at least 1, got 0)'
-          expect { pproc.call(rtime, too_few) }.to raise_error(err, ms1 + ms2)
+          expect { pproc.call(rtime, []) }.to raise_error(err, ms1 + ms2)
 
-          too_much = call_proc('newline', ['foo', 'bar'])
+          too_much = ['foo', 'bar']
           err = StandardError
           ms1 = 'Wrong number of arguments for #<Procedure cube>'
           ms2 = ' (required at least 1, got 2)'
@@ -127,16 +120,16 @@ module Skeem
           pproc = PrimitiveProcedure.new('sum', binary, sum)
           rtime = double('fake-runtime')
 
-          invokation = call_proc('sum', [SkmInteger.create(3), SkmInteger.create(5)])
-          expect(pproc.call(rtime, invokation)).to eq(8)
+          args = [SkmInteger.create(3), SkmInteger.create(5)]
+          expect(pproc.call(rtime, args)).to eq(8)
 
-          too_few = call_proc('sum', [SkmInteger.create(3)])
+          too_few = [SkmInteger.create(3)]
           err = StandardError
           ms1 = 'Wrong number of arguments for #<Procedure sum>'
           ms2 = ' (required at least 2, got 1)'
           expect { pproc.call(rtime, too_few) }.to raise_error(err, ms1 + ms2)
 
-          too_much = call_proc('cube', ['foo', 'bar', 'quux'])
+          too_much = ['foo', 'bar', 'quux']
           err = StandardError
           ms1 = 'Wrong number of arguments for #<Procedure sum>'
           ms2 = ' (required at least 2, got 3)'
@@ -147,13 +140,13 @@ module Skeem
           pproc = PrimitiveProcedure.new('length', zero_or_more, length)
           rtime = double('fake-runtime')
 
-          invokation = call_proc('length', [SkmInteger.create(3), SkmInteger.create(5)])
-          expect(pproc.call(rtime, invokation)).to eq(2)
+          args = [SkmInteger.create(3), SkmInteger.create(5)]
+          expect(pproc.call(rtime, args)).to eq(2)
 
-          no_arg = call_proc('sum', nil)
+          no_arg = []
           expect(pproc.call(rtime, no_arg)).to eq(0)
 
-          many = call_proc('cube', ['foo', 'bar', 'quux'])
+          many = ['foo', 'bar', 'quux']
           expect( pproc.call(rtime, many)).to eq(3)
         end
       end # context

data/spec/skeem/runtime_spec.rb

@@ -9,12 +9,12 @@ module Skeem
   describe Runtime do
     include DatumDSL
     
-    let(:some_env) { Environment.new }
+    let(:some_env) { SkmFrame.new }
     subject { Runtime.new(some_env) }
 
     context 'Initialization:' do
       it 'should be initialized with an environment' do
-        expect { Runtime.new(Environment.new) }.not_to raise_error
+        expect { Runtime.new(SkmFrame.new) }.not_to raise_error
       end
 
       it 'should know the environment' do
@@ -29,14 +29,16 @@ module Skeem
     context 'Provided services:' do
       it 'should add entries to the environment' do
         entry = double('dummy')
-        subject.define('dummy', entry)
+        expect(entry).to receive(:bound!)
+        subject.add_binding('dummy', entry)
         expect(subject.environment.size).to eq(1)
       end
 
       it 'should know the keys in the environment' do
         expect(subject.include?('dummy')).to be_falsey
         entry = double('dummy')
-        subject.define('dummy', entry)
+        expect(entry).to receive(:bound!)
+        subject.add_binding('dummy', entry)
         expect(subject.include?('dummy')).to be_truthy
       end
     end # context
@@ -63,24 +65,24 @@ module Skeem
       
     context 'Environment nesting:' do
       it 'should add nested environment' do
-        expect(subject.depth).to be_zero
+        expect(subject.depth).to eq(1)
         env_before = subject.environment
         subject.nest
         
         expect(subject.environment).not_to eq(env_before)
-        expect(subject.environment.outer).to eq(env_before)
-        expect(subject.depth).to eq(1)
+        expect(subject.environment.parent).to eq(env_before)
+        expect(subject.depth).to eq(2)
       end
 
       it 'should remove nested environment' do
-        expect(subject.depth).to be_zero
-        subject.nest
-        outer_before = subject.environment.outer
         expect(subject.depth).to eq(1)
+        subject.nest
+        parent_before = subject.environment.parent
+        expect(subject.depth).to eq(2)
         
         subject.unnest
-        expect(subject.environment).to eq(outer_before)
-        expect(subject.depth).to be_zero
+        expect(subject.environment).to eq(parent_before)
+        expect(subject.depth).to eq(1)
       end
     end # context
     

data/spec/skeem/s_expr_nodes_spec.rb

@@ -5,84 +5,6 @@ require_relative '../../lib/skeem/primitive/primitive_builder'
 require_relative '../../lib/skeem/s_expr_nodes' # Load the classes under test
 
 module Skeem
-  describe SkmDefinition do
-    let(:pos) { double('fake-position') }
-    let(:sample_symbol) { SkmIdentifier.create('ten') }
-    let(:sample_expr) { SkmInteger.create(10) }
-
-    subject { SkmDefinition.new(pos, sample_symbol, sample_expr) }
-
-    context 'Initialization:' do
-      it 'should be initialized with a symbol and an expression' do
-        expect{ SkmDefinition.new(pos, sample_symbol, sample_expr) }.not_to raise_error
-      end
-
-      it 'should know its variable' do
-        expect(subject.variable).to eq(sample_symbol)
-      end
-
-      it 'should know its expression' do
-        expect(subject.expression).to eq(sample_expr)
-      end
-    end # context
-
-    context 'Provided services:' do
-      include Primitive::PrimitiveBuilder
-
-      let(:runtime) { Runtime.new(Environment.new) }
-
-      it 'should create an entry when evaluating' do
-        expect(runtime).not_to include(sample_symbol)
-        subject.evaluate(runtime)
-        expect(runtime).to include(sample_symbol)
-      end
-
-      it 'should optimize an entry that aliases a primitive proc' do
-        add_primitives(runtime)
-        identifier = SkmIdentifier.create('plus')
-        proc_name = SkmIdentifier.create('+')
-        var_ref = SkmVariableReference.new(nil, proc_name)
-        instance = SkmDefinition.new(nil, identifier, var_ref) # (define plus +)
-        expect(instance.expression).to eq(var_ref)
-        instance.evaluate(runtime)
-        # Optimization by getting rid of indirection
-        expect(instance.expression).to be_kind_of(Primitive::PrimitiveProcedure)
-      end
-
-      it 'should optimize an entry that aliases a lambda proc' do
-        # Let's define a (dummy) lambda
-        formals = SkmFormals.new([], :fixed)
-        dummy_body = { :defs => [], :sequence => [SkmInteger.create(3)]}
-        lbd = SkmLambda.new(nil, formals, dummy_body)
-        id = SkmIdentifier.create('some-lambda')
-        def1 = SkmDefinition.new(nil, id, lbd)
-        def1.evaluate(runtime)
-
-        # Let's create an alias to the lambda
-        other_name = SkmIdentifier.create('aliased-lambda')
-        var_ref = SkmVariableReference.new(nil, id)
-
-        # (define aliased-lambda some-lambda)
-        def2 = SkmDefinition.new(nil, other_name, var_ref)
-        expect(def2.expression).to eq(var_ref)
-        def2.evaluate(runtime)
-        # Optimization by getting rid of indirection
-        expect(def2.expression).to eq(lbd)
-      end
-
-      it 'should quasiquote its variable and expression' do
-        alter_ego = subject.quasiquote(runtime)
-        expect(alter_ego).to eq(subject)
-      end
-
-      it 'should return its text representation' do
-        txt1 = '<Skeem::SkmDefinition: <Skeem::SkmIdentifier: ten>,'
-        txt2 = ' <Skeem::SkmInteger: 10>>'
-        expect(subject.inspect).to eq(txt1 + txt2)
-      end
-    end # context
-  end # describe
-
   describe ProcedureCall do
      let(:pos) { double('fake-position') }
     let(:operator) { SkmIdentifier.create('+') }
@@ -180,9 +102,11 @@ module Skeem
       it 'should return its text representation' do
         txt1 = '<Skeem::SkmLambda: @formals #<Double "fake-formals">, '
         txt2 = '@definitions #<Double "fake-definitions">, '
-        txt3 = '@sequence #<Double "fake-sequence">>'
-        expect(subject.inspect).to eq(txt1 + txt2 + txt3)
-      end
+        txt3 = '@sequence #<Double "fake-sequence">>>'
+        # Remove "unpredictable" part of actual text
+        expectation = subject.inspect.gsub(/@object_id=[0-9a-z]+, /, '')
+        expect(expectation).to eq(txt1 + txt2 + txt3)
+      end  
     end # context
   end # describe
 end # module

data/spec/skeem/skm_frame_spec.rb

@@ -0,0 +1,119 @@
+require_relative '../spec_helper' # Use the RSpec framework
+require_relative '../../lib/skeem/datum_dsl' 
+require_relative '../../lib/skeem/skm_frame' # Load the class under test
+
+module Skeem
+  describe SkmFrame do
+    include DatumDSL
+
+    let(:sample_env) { SkmFrame.new }
+    context 'Initialization:' do
+      it 'could be initialized without argument' do
+        expect { SkmFrame.new() }.not_to raise_error
+      end
+
+      it 'could be initialized with optional argument' do
+        expect { SkmFrame.new(sample_env) }.not_to raise_error
+      end
+
+      it 'should have no default bindings' do
+        expect(subject).to be_empty
+      end
+
+      it 'should have depth of zero or one' do
+        expect(subject.depth).to be_zero
+
+        instance = SkmFrame.new(sample_env)
+        expect(instance.depth).to eq(1)
+      end
+    end # context
+
+    context 'Provided services:' do
+      it 'should add binding' do
+        entry = double('original-dummy')
+        expect(entry).to receive(:bound!).with(subject)
+
+        subject.add_binding('dummy', entry)
+        expect(subject.size).to eq(1)
+        expect(subject.bindings['dummy']).not_to be_nil
+        expect(subject.bindings['dummy']).to eq(entry)
+
+        # A child frame may shadow a parent's variable
+        child = SkmFrame.new(subject)
+        entry2 = double('dummy')
+        expect(entry2).to receive(:bound!).with(child)
+        child.add_binding(identifier('dummy'), entry2)
+
+        expect(child.bindings['dummy']).to eq(entry2)
+        expect(subject.bindings['dummy']).to eq(entry)
+      end
+
+      it 'should update bindings' do
+        entry1 = double('dummy')
+        expect(entry1).to receive(:bound!).with(subject)
+
+        # Case 1: entry defined in this frame
+        subject.add_binding('dummy', entry1)
+        expect(subject.bindings['dummy']).to eq(entry1)
+
+        entry2 = double('still-dummy')
+        expect(entry2).to receive(:bound!).with(subject)
+        subject.update_binding(identifier('dummy'), entry2)
+        expect(subject.bindings['dummy']).to eq(entry2)
+
+        # Case 2: entry defined in parent frame
+        child = SkmFrame.new(subject)
+        entry3 = double('still-dummy')
+        expect(entry3).to receive(:bound!).with(subject)
+        child.update_binding('dummy', entry3)
+        expect(subject.bindings['dummy']).to eq(entry3)
+      end
+
+      it 'should retrieve entries' do
+        # Case 1: non-existing entry
+        expect(subject.fetch('dummy')).to be_nil
+
+        # Case 2: existing entry
+        entry = double('dummy')
+        expect(entry).to receive(:bound!).with(subject)
+        subject.add_binding('dummy', entry)
+        expect(subject.fetch('dummy')).to eq(entry)
+
+        # Case 3: entry defined in parent frame
+        child = SkmFrame.new(subject)
+        expect(child.fetch(identifier('dummy'))).to eq(entry)
+      end
+
+      it 'should know whether it is empty' do
+        # Case 1: no entry
+        expect(subject.empty?).to be_truthy
+
+        # Case 2: existing entry
+        entry = double('dummy')
+        expect(entry).to receive(:bound!).with(subject)
+        subject.add_binding('dummy', entry)
+        expect(subject.empty?).to be_falsey
+
+        # Case 3: entry defined in parent frame
+        nested = SkmFrame.new(subject)
+        expect(nested.empty?).to be_falsey
+      end
+
+      it 'should know the total number of bindings' do
+        # Case 1: non-existing entry
+        expect(subject.size).to be_zero
+
+        # Case 2: existing entry
+        entry = double('dummy')
+        expect(entry).to receive(:bound!).with(subject)
+        subject.add_binding('dummy', entry)
+        expect(subject.size).to eq(1)
+
+        # Case 3: entry defined in parent environment
+        nested = SkmFrame.new(subject)
+        expect(nested.size).to eq(1)
+      end
+    end # context
+
+  end # describe
+end # module