skeem 0.0.23 → 0.0.24

data/spec/skeem/interpreter_spec.rb

@@ -39,7 +39,7 @@ module Skeem
         samples.each do |source, predicted|
           result = subject.run(source)
           expect(result).to be_kind_of(SkmBoolean)
-          expect(result.value).to eq(predicted)
+          expect(result).to eq(predicted)
         end
       end
 
@@ -54,7 +54,7 @@ module Skeem
         samples.each do |source, predicted|
           result = subject.run(source)
           expect(result).to be_kind_of(SkmInteger)
-          expect(result.value).to eq(predicted)
+          expect(result).to eq(predicted)
         end
       end
 
@@ -69,7 +69,7 @@ module Skeem
         samples.each do |source, predicted|
           result = subject.run(source)
           expect(result).to be_kind_of(SkmReal)
-          expect(result.value).to eq(predicted)
+          expect(result).to eq(predicted)
         end
       end
 
@@ -80,7 +80,7 @@ module Skeem
         samples.each do |source, predicted|
           result = subject.run(source)
           expect(result).to be_kind_of(SkmString)
-          expect(result.value).to eq(predicted)
+          expect(result).to eq(predicted)
         end
       end
 
@@ -95,8 +95,8 @@ module Skeem
           [SkmString, 'Sat']
         ]
         predictions.each_with_index do |(type, value), index|
-          expect(result.elements[index]).to be_kind_of(type)
-          expect(result.elements[index].value).to eq(value)
+          expect(result.members[index]).to be_kind_of(type)
+          expect(result.members[index]).to eq(value)
         end
       end
     end # context
@@ -116,7 +116,7 @@ SKEEM
         result = subject.run(source)
         end_result = result.last
         expect(end_result).to be_kind_of(SkmInteger)
-        expect(end_result.value).to eq(28)
+        expect(end_result).to eq(28)
       end
 
       it 'should implement the simple conditional form' do
@@ -126,7 +126,7 @@ SKEEM
         ]
         checks.each do |(skeem_expr, expectation)|
           result = subject.run(skeem_expr)
-          expect(result.value).to eq(expectation)
+          expect(result).to eq(expectation)
         end
       end
 
@@ -137,7 +137,7 @@ SKEEM
         ]
         checks.each do |(skeem_expr, expectation)|
           result = subject.run(skeem_expr)
-          expect(result.value).to eq(expectation)
+          expect(result).to eq(expectation)
         end
         source = <<-SKEEM
   ; Example from R7RS section 4.1.5
@@ -146,7 +146,7 @@ SKEEM
     (+ 3 2))
 SKEEM
         result = subject.run(source)
-        expect(result.value).to eq(1)
+        expect(result).to eq(1)
       end
 
       it 'should implement the quotation of constant literals' do
@@ -162,7 +162,7 @@ SKEEM
         ]
         checks.each do |(skeem_expr, expectation)|
           result = subject.run(skeem_expr)
-          expect(result.value).to eq(expectation)
+          expect(result).to eq(expectation)
         end
       end
 
@@ -176,8 +176,8 @@ SKEEM
           [SkmIdentifier, 'c']
         ]
         predictions.each_with_index do |(type, value), index|
-          expect(result.elements[index]).to be_kind_of(type)
-          expect(result.elements[index].value).to eq(value)
+          expect(result.members[index]).to be_kind_of(type)
+          expect(result.members[index]).to eq(value)
         end
       end
 
@@ -192,13 +192,13 @@ SKEEM
         ]
         predictions.each_with_index do |(type, value), index|
           expect(result.members[index]).to be_kind_of(type)
-          expect(result.members[index].value).to eq(value)
+          expect(result.members[index]).to eq(value)
         end
-        
+
         source = "'()"
         result = subject.run(source)
         expect(result).to be_kind_of(SkmList)
-        expect(result).to be_empty
+        expect(result).to be_null
       end      
 
       it 'should implement the lambda function with one arg' do
@@ -212,11 +212,11 @@ SKEEM
         procedure = subject.fetch('abs').expression
         expect(procedure.arity).to eq(1)
         result = subject.run('(abs -3)')
-        expect(result.value).to eq(3)
+        expect(result).to eq(3)
         result = subject.run('(abs 0)')
-        expect(result.value).to eq(0)
+        expect(result).to eq(0)
         result = subject.run('(abs 3)')
-        expect(result.value).to eq(3)
+        expect(result).to eq(3)
       end
 
       it 'should implement the lambda function with two args' do
@@ -230,11 +230,11 @@ SKEEM
         procedure = subject.fetch('min').expression
         expect(procedure.arity).to eq(2)
         result = subject.run('(min 1 2)')
-        expect(result.value).to eq(1)
+        expect(result).to eq(1)
         result = subject.run('(min 2 1)')
-        expect(result.value).to eq(1)
+        expect(result).to eq(1)
         result = subject.run('(min 2 2)')
-        expect(result.value).to eq(2)
+        expect(result).to eq(2)
       end
 
       it 'should implement recursive functions' do
@@ -253,7 +253,7 @@ SKEEM
       it 'should accept calls to anonymous procedures' do
         source = '((lambda (x) (+ x x)) 4)'
         result = subject.run(source)
-        expect(result.value).to eq(8)
+        expect(result).to eq(8)
       end
 
       it 'should support procedures with variable number of arguments' do
@@ -270,8 +270,8 @@ SKEEM
         result = subject.run(source)
         expect(result).to be_kind_of(SkmList)
         expect(result.length).to eq(2)
-        expect(result.head.value).to eq(5)
-        expect(result.last.value).to eq(6)
+        expect(result.head).to eq(5)
+        expect(result.last).to eq(6)
       end
 
       it 'should implement the compact define + lambda syntax' do
@@ -297,17 +297,107 @@ SKEEM
       end
     end # context
 
+    context 'Quasiquotation:' do
+      it 'should implement the quasiquotation of constant literals' do
+         checks = [
+          ['(quasiquote a)', 'a'],
+          ['(quasiquote 145932)', 145932],
+          ['(quasiquote "abc")', 'abc'],
+          ['(quasiquote #t)', true],
+          ['`a', 'a'],
+          ['`145932', 145932],
+          ['`"abc"', 'abc'],
+          ['`#t', true]
+        ]
+        checks.each do |(skeem_expr, expectation)|
+          result = subject.run(skeem_expr)
+          expect(result).to eq(expectation)
+        end
+      end
+
+      it 'should implement the quasiquotation of vectors' do
+        source = '(quasiquote #(a b c))'
+        result = subject.run(source)
+        expect(result).to be_kind_of(SkmVector)
+        predictions = [
+          [SkmIdentifier, 'a'],
+          [SkmIdentifier, 'b'],
+          [SkmIdentifier, 'c']
+        ]
+        predictions.each_with_index do |(type, value), index|
+          expect(result.members[index]).to be_kind_of(type)
+          expect(result.members[index]).to eq(value)
+        end
+      end
+            
+      it 'should implement the quasiquotation of lists' do
+        source = '(quasiquote (+ 1 2))'
+        result = subject.run(source)
+        expect(result).to be_kind_of(SkmList)
+        predictions = [
+          [SkmIdentifier, '+'],
+          [SkmInteger, 1],
+          [SkmInteger, 2]
+        ]
+        predictions.each_with_index do |(type, value), index|
+          expect(result.members[index]).to be_kind_of(type)
+          expect(result.members[index]).to eq(value)
+        end
+
+        source = "`()"
+        result = subject.run(source)
+        expect(result).to be_kind_of(SkmList)
+        expect(result).to be_null
+      end
+      
+      it 'should implement the unquote of lists' do
+        source = '`(list ,(+ 1 2) 4)'
+        result = subject.run(source)
+        expect(result).to be_kind_of(SkmList)
+        predictions = [
+          [SkmIdentifier, 'list'],
+          [SkmInteger, 3],
+          [SkmInteger, 4]
+        ]
+        predictions.each_with_index do |(type, value), index|
+          expect(result.members[index]).to be_kind_of(type)
+          expect(result.members[index]).to eq(value)
+        end
+
+        source = "`()"
+        result = subject.run(source)
+        expect(result).to be_kind_of(SkmList)
+        expect(result).to be_null
+      end
+=begin
+`(+ 2 ,(* 3 4))  (+ 2 12)
+`(a b (,(+ 2 3) c) d)  (a b (5 c) d)
+`(a b ,(reverse '(c d e)) f g)  (a b (e d c) f g)
+(let ([a 1] [b 2])
+  `(,a . ,b))  (1 . 2) 
+
+`(+ ,@(cdr '(* 2 3)))  (+ 2 3)
+`(a b ,@(reverse '(c d e)) f g)  (a b e d c f g)
+(let ([a 1] [b 2])
+  `(,a ,@b))  (1 . 2)
+`#(,@(list 1 2 3))  #(1 2 3) 
+
+'`,(cons 'a 'b)  `,(cons 'a 'b)
+`',(cons 'a 'b)  '(a . b) 
+=end
+    end # context
+
     context 'Built-in primitive procedures' do
       it 'should implement the division of numbers' do
         result = subject.run('(/ 24 3)')
         expect(result).to be_kind_of(SkmInteger)
-        expect(result.value).to eq(8)
+        expect(result).to eq(8)
       end
 
       it 'should handle arithmetic expressions' do
         result = subject.run('(+ (* 2 100) (* 1 10))')
         expect(result).to be_kind_of(SkmInteger)
-        expect(result.value).to eq(210)
+        expect(result).to eq(210)
       end
     end # context
 
@@ -323,7 +413,7 @@ SKEEM
         ]
         checks.each do |(skeem_expr, expectation)|
           result = subject.run(skeem_expr)
-          expect(result.value).to eq(expectation)
+          expect(result).to eq(expectation)
         end
       end
 
@@ -338,7 +428,7 @@ SKEEM
         ]
         checks.each do |(skeem_expr, expectation)|
           result = subject.run(skeem_expr)
-          expect(result.value).to eq(expectation)
+          expect(result).to eq(expectation)
         end
       end
 
@@ -353,7 +443,7 @@ SKEEM
         ]
         checks.each do |(skeem_expr, expectation)|
           result = subject.run(skeem_expr)
-          expect(result.value).to eq(expectation)
+          expect(result).to eq(expectation)
         end
       end
 
@@ -368,7 +458,7 @@ SKEEM
         ]
         checks.each do |(skeem_expr, expectation)|
           result = subject.run(skeem_expr)
-          expect(result.value).to eq(expectation)
+          expect(result).to eq(expectation)
         end
       end
 
@@ -381,7 +471,7 @@ SKEEM
         ]
         checks.each do |(skeem_expr, expectation)|
           result = subject.run(skeem_expr)
-          expect(result.value).to eq(expectation)
+          expect(result).to eq(expectation)
         end
       end
 
@@ -394,7 +484,7 @@ SKEEM
         ]
         checks.each do |(skeem_expr, expectation)|
           result = subject.run(skeem_expr)
-          expect(result.value).to eq(expectation)
+          expect(result).to eq(expectation)
         end
       end
 
@@ -409,7 +499,7 @@ SKEEM
         ]
         checks.each do |(skeem_expr, expectation)|
           result = subject.run(skeem_expr)
-          expect(result.value).to eq(expectation)
+          expect(result).to eq(expectation)
         end
       end
 
@@ -421,7 +511,7 @@ SKEEM
         ]
         checks.each do |(skeem_expr, expectation)|
           result = subject.run(skeem_expr)
-          expect(result.value).to eq(expectation)
+          expect(result).to eq(expectation)
         end
       end
 
@@ -433,7 +523,7 @@ SKEEM
         ]
         checks.each do |(skeem_expr, expectation)|
           result = subject.run(skeem_expr)
-          expect(result.members.map(&:value)).to eq(expectation)
+          expect(result.members).to eq(expectation)
         end
       end
     end # context

data/spec/skeem/primitive/primitive_builder_spec.rb

@@ -16,7 +16,7 @@ module Skeem
             ['(+ 2 2.34)', 4.34]
           ].each do |(expr, predicted)|
             result = subject.run(expr)
-            expect(result.value).to eq(predicted)
+            expect(result).to eq(predicted)
           end
         end
 
@@ -27,7 +27,7 @@ module Skeem
             ['(- 3 4 5)', -6] # '-' as variadic operator. Example from section 6.2.6
           ].each do |(expr, predicted)|
             result = subject.run(expr)
-            expect(result.value).to eq(predicted)
+            expect(result).to eq(predicted)
           end
         end
 
@@ -39,7 +39,7 @@ module Skeem
             ['(* 2 3 4 5)', 120] # '*' as variadic operator.
           ].each do |(expr, predicted)|
             result = subject.run(expr)
-            expect(result.value).to eq(predicted)
+            expect(result).to eq(predicted)
           end
         end
 
@@ -50,7 +50,7 @@ module Skeem
             ['(/ 3 4 5)', 3.0/20] # '/' as variadic operator. Example from section 6.2.6
           ].each do |(expr, predicted)|
             result = subject.run(expr)
-            expect(result.value).to eq(predicted)
+            expect(result).to eq(predicted)
           end
         end
 
@@ -64,7 +64,7 @@ module Skeem
           ]
           checks.each do |(skeem_expr, expectation)|
             result = subject.run(skeem_expr)
-            expect(result.value).to eq(expectation)
+            expect(result).to eq(expectation)
           end
         end
       end # context
@@ -81,7 +81,7 @@ module Skeem
           ]
           checks.each do |(skeem_expr, expectation)|
             result = subject.run(skeem_expr)
-            expect(result.value).to eq(expectation)
+            expect(result).to eq(expectation)
           end
         end
 
@@ -111,7 +111,7 @@ module Skeem
           ]
           checks.each do |(skeem_expr, expectation)|
             result = subject.run(skeem_expr)
-            expect(result.value).to eq(expectation)
+            expect(result).to eq(expectation)
           end
         end
 
@@ -127,7 +127,7 @@ module Skeem
           ]
           checks.each do |(skeem_expr, expectation)|
             result = subject.run(skeem_expr)
-            expect(result.value).to eq(expectation)
+            expect(result).to eq(expectation)
           end
         end
 
@@ -143,7 +143,7 @@ module Skeem
           ]
           checks.each do |(skeem_expr, expectation)|
             result = subject.run(skeem_expr)
-            expect(result.value).to eq(expectation)
+            expect(result).to eq(expectation)
           end
         end
       end # context
@@ -158,7 +158,7 @@ module Skeem
           ]
           checks.each do |(skeem_expr, expectation)|
             result = subject.run(skeem_expr)
-            expect(result.value).to eq(expectation)
+            expect(result).to eq(expectation)
           end
         end
 
@@ -171,7 +171,7 @@ module Skeem
           ]
           checks.each do |(skeem_expr, expectation)|
             result = subject.run(skeem_expr)
-            expect(result.value).to eq(expectation)
+            expect(result).to eq(expectation)
           end
         end
 
@@ -185,7 +185,7 @@ module Skeem
           ]
           checks.each do |(skeem_expr, expectation)|
             result = subject.run(skeem_expr)
-            expect(result.value).to eq(expectation)
+            expect(result).to eq(expectation)
           end
         end
 
@@ -198,7 +198,7 @@ module Skeem
           ]
           checks.each do |(skeem_expr, expectation)|
             result = subject.run(skeem_expr)
-            expect(result.value).to eq(expectation)
+            expect(result).to eq(expectation)
           end
         end
       end # context
@@ -212,7 +212,7 @@ module Skeem
           ]
           checks.each do |(skeem_expr, expectation)|
             result = subject.run(skeem_expr)
-            expect(result.value).to eq(expectation)
+            expect(result).to eq(expectation)
           end
         end
 
@@ -224,7 +224,7 @@ module Skeem
           ]
           checks.each do |(skeem_expr, expectation)|
             result = subject.run(skeem_expr)
-            expect(result.value).to eq(expectation)
+            expect(result).to eq(expectation)
           end
 
           # If all the expressions evaluate to true values,
@@ -232,8 +232,8 @@ module Skeem
           source = "(and 1 2 'c '(f g))"
           result = subject.run(source)
           expect(result).to be_kind_of(SkmList)
-          expect(result.head.value).to eq('f')
-          expect(result.last.value).to eq('g')
+          expect(result.head).to eq('f')
+          expect(result.last).to eq('g')
         end
 
         it 'should implement the or procedure' do
@@ -248,7 +248,7 @@ module Skeem
           ]
           checks.each do |(skeem_expr, expectation)|
             result = subject.run(skeem_expr)
-            expect(result.value).to eq(expectation)
+            expect(result).to eq(expectation)
           end
 
           # When an expression evaluates to true value,
@@ -256,7 +256,7 @@ module Skeem
           source = "(or #f 'a #f)"
           result = subject.run(source)
           expect(result).to be_kind_of(SkmIdentifier)
-          expect(result.value).to eq('a')
+          expect(result).to eq('a')
         end
 
         it 'should implement the boolean? procedure' do
@@ -266,7 +266,7 @@ module Skeem
           ]
           checks.each do |(skeem_expr, expectation)|
             result = subject.run(skeem_expr)
-            expect(result.value).to eq(expectation)
+            expect(result).to eq(expectation)
           end
         end
       end # context
@@ -280,7 +280,7 @@ module Skeem
           ]
           checks.each do |(skeem_expr, expectation)|
             result = subject.run(skeem_expr)
-            expect(result.value).to eq(expectation)
+            expect(result).to eq(expectation)
           end
         end
 
@@ -290,10 +290,10 @@ module Skeem
           ]
           checks.each do |(skeem_expr, expectation)|
             result = subject.run(skeem_expr)
-            expect(result.value).to eq(expectation)
+            expect(result).to eq(expectation)
           end
         end
-        
+
         it 'should implement the string-append procedure' do
           checks = [
             ['(string-append)', ''],
@@ -302,7 +302,19 @@ module Skeem
           ]
           checks.each do |(skeem_expr, expectation)|
             result = subject.run(skeem_expr)
-            expect(result.value).to eq(expectation)
+            expect(result).to eq(expectation)
+          end
+        end
+
+       it 'should implement the string-length procedure' do
+          checks = [
+            ['(string-length "abc")', 3],
+            ['(string-length "")', 0],
+            ['(string-length "hi there")', 8],
+          ]
+          checks.each do |(skeem_expr, expectation)|
+            result = subject.run(skeem_expr)
+            expect(result).to eq(expectation)
           end
         end
       end # context
@@ -315,7 +327,7 @@ module Skeem
           ]
           checks.each do |(skeem_expr, expectation)|
             result = subject.run(skeem_expr)
-            expect(result.value).to eq(expectation)
+            expect(result).to eq(expectation)
           end
         end
       end # context
@@ -323,15 +335,15 @@ module Skeem
       context 'List procedures:' do
         it 'should implement the list? procedure' do
           checks = [
-            ['(list? #f)', false],
-            ['(list? 1)', false],
-            ['(list? "bar")', false],
-            ['(list? (list 1 2 3))', true],
+            #['(list? #f)', false],
+            #['(list? 1)', false],
+            #['(list? "bar")', false],
+            #['(list? (list 1 2 3))', true],
             ['(list? (list))', true]
           ]
           checks.each do |(skeem_expr, expectation)|
             result = subject.run(skeem_expr)
-            expect(result.value).to eq(expectation)
+            expect(result).to eq(expectation)
           end
         end
 
@@ -347,7 +359,7 @@ module Skeem
           ]
           checks.each do |(skeem_expr, expectation)|
             result = subject.run(skeem_expr)
-            expect(result.value).to eq(expectation)
+            expect(result).to eq(expectation)
           end
         end
 
@@ -360,7 +372,7 @@ module Skeem
           ]
           checks.each do |(skeem_expr, expectation)|
             result = subject.run(skeem_expr)
-            expect(result.value).to eq(expectation)
+            expect(result).to eq(expectation)
           end
         end
       end # context
@@ -376,7 +388,7 @@ module Skeem
           ]
           checks.each do |(skeem_expr, expectation)|
             result = subject.run(skeem_expr)
-            expect(result.value).to eq(expectation)
+            expect(result).to eq(expectation)
           end
         end
 
@@ -389,7 +401,7 @@ module Skeem
           source = '(vector 1 2 3)'
           result = subject.run(source)
           expect(result).to be_kind_of(SkmVector)
-          expect(result.elements.map(&:value)).to eq([1, 2, 3])
+          expect(result.members).to eq([1, 2, 3])
         end
 
         it 'should implement the vector-length procedure' do
@@ -404,7 +416,7 @@ module Skeem
           ]
           checks.each do |(skeem_expr, expectation)|
             result = subject.run(skeem_expr)
-            expect(result.value).to eq(expectation)
+            expect(result).to eq(expectation)
           end
         end
 
@@ -412,7 +424,7 @@ module Skeem
           source = "(vector-ref '#(1 1 2 3 5 8 13 21) 5)"
           result = subject.run(source)
           expect(result).to be_kind_of(SkmInteger)
-          expect(result.value).to eq(8)
+          expect(result).to eq(8)
         end
       end # context
 

data/spec/skeem/runtime_spec.rb

@@ -1,9 +1,13 @@
 require_relative '../spec_helper' # Use the RSpec framework
-require_relative '../../lib/skeem/environment' # Load the class under test
+require_relative '../../lib/skeem/datum_dsl'
+require_relative '../../lib/skeem/primitive/primitive_builder'
+
 require_relative '../../lib/skeem/runtime' # Load the class under test
 
 module Skeem
   describe Runtime do
+    include DatumDSL
+    
     let(:some_env) { Environment.new }
     subject { Runtime.new(some_env) }
 
@@ -30,7 +34,29 @@ module Skeem
         subject.define('dummy', entry)
         expect(subject.include?('dummy')).to be_truthy
       end
-
+    end # context
+      
+    context 'Evaluation:' do
+      include Primitive::PrimitiveBuilder
+      
+      it 'should evaluate a given entry' do
+        entry = double('three')
+        result = double('fake-procedure')
+        expect(entry).to receive(:expression).and_return(result)
+        expect(result).to receive(:evaluate).with(subject).and_return(integer(3))
+        subject.define('three', entry)
+        expect(subject.evaluate('three')).to eq(3)
+      end
+      
+      it 'should evaluate a given list' do
+        add_primitives(subject)
+        sum = list([identifier('+'), 3, 4])
+        
+        expect(subject.evaluate_form(sum)).to eq(7)
+      end
+    end # context
+      
+    context 'Environment nesting' do
       it 'should add nested environment' do
         expect(subject.depth).to be_zero
         env_before = subject.environment