skeem 0.0.28 → 0.1.00

data/spec/skeem/interpreter_spec.rb

@@ -187,20 +187,21 @@ SKEEM
       it 'should implement the quotation of lists' do
         source = '(quote (+ 1 2))'
         result = subject.run(source)
-        expect(result).to be_kind_of(SkmList)
+        expect(result).to be_kind_of(SkmPair)
         predictions = [
           [SkmIdentifier, '+'],
           [SkmInteger, 1],
           [SkmInteger, 2]
         ]
+        members = result.to_a
         predictions.each_with_index do |(type, value), index|
-          expect(result.members[index]).to be_kind_of(type)
-          expect(result.members[index]).to eq(value)
+          expect(members[index]).to be_kind_of(type)
+          expect(members[index]).to eq(value)
         end
 
         source = "'()"
         result = subject.run(source)
-        expect(result).to be_kind_of(SkmList)
+        expect(result).to be_kind_of(SkmEmptyList)
         expect(result).to be_null
       end
 
@@ -263,7 +264,7 @@ SKEEM
         # Example from R7RS section 4.1.4
         source = '((lambda x x) 3 4 5 6)'
         result = subject.run(source)
-        expect(result).to be_kind_of(SkmList)
+        expect(result).to be_kind_of(SkmPair)
         expect(result.length).to eq(4)
       end
 
@@ -271,9 +272,9 @@ SKEEM
         # Example from R7RS section 4.1.4
         source = '((lambda (x y . z) z) 3 4 5 6)'
         result = subject.run(source)
-        expect(result).to be_kind_of(SkmList)
+        expect(result).to be_kind_of(SkmPair)
         expect(result.length).to eq(2)
-        expect(result.head).to eq(5)
+        expect(result.first).to eq(5)
         expect(result.last).to eq(6)
       end
 
@@ -371,56 +372,59 @@ SKEEM
       it 'should implement the quasiquotation of lists' do
         source = '(quasiquote (+ 1 2))'
         result = subject.run(source)
-        expect(result).to be_kind_of(SkmList)
+        expect(result).to be_kind_of(SkmPair)
         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)
+        predictions.each do |(type, value)|
+          expect(result.car).to be_kind_of(type)
+          expect(result.car).to eq(value)
+          result = result.cdr
         end
 
         source = "`()"
         result = subject.run(source)
-        expect(result).to be_kind_of(SkmList)
+        expect(result).to be_kind_of(SkmEmptyList)
         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)
+        expect(result).to be_kind_of(SkmPair)
         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)
+        predictions.each do |(type, value)|
+          expect(result.car).to be_kind_of(type)
+          expect(result.car).to eq(value)
+          result = result.cdr
         end
 
         source = "`()"
         result = subject.run(source)
-        expect(result).to be_kind_of(SkmList)
+        expect(result).to be_kind_of(SkmEmptyList)
         expect(result).to be_null
 
         # nested lists
         source = '`(a b (,(+ 2 3) c) d)'
         result = subject.run(source)
         # expected: (a b (5 c) d)
-        expect(result).to be_kind_of(SkmList)
+        expect(result).to be_kind_of(SkmPair)
         predictions = [
           [SkmIdentifier, 'a'],
           [SkmIdentifier, 'b'],
-          [SkmList, list([integer(5), identifier('c')])],
+          [SkmPair, list([integer(5), identifier('c')])],
           [SkmIdentifier, 'd']
         ]
-        predictions.each_with_index do |(type, value), index|
-          expect(result.members[index]).to be_kind_of(type)
-          expect(result.members[index]).to eq(value)
+        predictions.each do |(type, value)|
+          expect(result.car).to be_kind_of(type)
+          expect(result.car).to eq(value)
+          result = result.cdr
         end
       end
 =begin
@@ -592,7 +596,7 @@ SKEEM
         ]
         checks.each do |(skeem_expr, expectation)|
           result = subject.run(skeem_expr)
-          expect(result.members).to eq(expectation)
+          expect(result.to_a).to eq(expectation)
         end
       end
 
@@ -619,7 +623,7 @@ SKEEM
   ((compose list square) 5)
 SKEEM
         result = subject.run(source)
-        expect(result.last.members).to eq([25])
+        expect(result.last.car).to eq(25)
       end
 
       it 'should implement lambda that calls second-order functions' do
@@ -637,7 +641,7 @@ SKEEM
   ((repeat twice) 5)
 SKEEM
         result = subject.run(source)
-        expect(result.members.last).to eq(20)
+        expect(result.last).to eq(20)
       end
     end # context
   end # describe

data/spec/skeem/parser_spec.rb

@@ -17,9 +17,9 @@ module Skeem
       it 'should parse isolated booleans' do
         samples = [
         ['#f', false],
-        ['#false', false],
-        ['#t', true],
-        ['#true', true]
+#        ['#false', false],
+#        ['#t', true],
+#        ['#true', true]
       ]
         samples.each do |source, predicted|
           ptree = subject.parse(source)

data/spec/skeem/primitive/primitive_builder_spec.rb

@@ -7,7 +7,7 @@ module Skeem
   module Primitive
     describe 'Testing primitive procedures' do
       subject { Interpreter.new }
-      
+
       context 'Arithmetic operators:' do
         it 'should implement the set! form' do
           skeem1 = <<-SKEEM
@@ -22,7 +22,7 @@ SKEEM
 SKEEM
           result = subject.run(skeem2)
           expect(result.last).to eq(5)  # x is now bound to value 4
-        end        
+        end
       end # context
 
       context 'Arithmetic operators:' do
@@ -105,9 +105,9 @@ SKEEM
           checks.each do |(skeem_expr, expectation)|
             result = subject.run(skeem_expr)
             expect(result).to eq(expectation)
-          end          
+          end
         end
-        
+
         it 'should implement the equality operator' do
           checks = [
             ['(= 3)', true], # '=' as unary operator
@@ -257,9 +257,10 @@ SKEEM
           # the values of the last expression are returned.
           source = "(and 1 2 'c '(f g))"
           result = subject.run(source)
-          expect(result).to be_kind_of(SkmList)
-          expect(result.head).to eq('f')
-          expect(result.last).to eq('g')
+          expect(result).to be_kind_of(SkmPair)
+          expect(result.car).to eq('f')
+          expect(result.cdr).to be_kind_of(SkmPair)
+          expect(result.cdr.car).to eq('g')
         end
 
         it 'should implement the or procedure' do
@@ -370,10 +371,23 @@ SKEEM
             result = subject.run(skeem_expr)
             expect(result).to eq(expectation)
           end
-        end       
+        end
       end # context
 
       context 'List procedures:' do
+        it 'should implement the pair? procedure' do
+          checks = [
+            ["(pair? '(a . b))", true],
+            ["(pair? '(a b c))", true],
+            ["(pair? '())", false],
+            ["(pair? '#(a b))", false]
+          ]
+          checks.each do |(skeem_expr, expectation)|
+            result = subject.run(skeem_expr)
+            expect(result).to eq(expectation)
+          end
+        end
+
         it 'should implement the list? procedure' do
           checks = [
             ['(list? #f)', false],
@@ -404,6 +418,79 @@ SKEEM
           end
         end
 
+        it 'should implement the cons procedure' do
+          example = "(cons 'a '())" # => (a)
+          result = subject.run(example)
+          expect(result).to be_list
+          expect(result.car).to eq('a')
+
+          example = "(cons '(a) '(b c d))" # => ((a) b c d)
+          result = subject.run(example)
+          expect(result).to be_list
+          members = result.to_a
+          expect(members[0]).to be_list
+          expect(members[0].car).to eq('a')
+          expect(members[1]).to eq('b')
+          expect(members[2]).to eq('c')
+          expect(members[3]).to eq('d')
+
+          example = "(cons \"a\" '(b c))" # => ("a" b c)
+          result = subject.run(example)
+          expect(result).to be_list
+          expect(result.car).to be_kind_of(SkmString)
+          expect(result.car).to eq('a')
+          expect(result.cdr.car).to be_kind_of(SkmIdentifier)
+          expect(result.cdr.car).to eq('b')
+          expect(result.cdr.cdr.car).to be_kind_of(SkmIdentifier)
+          expect(result.cdr.cdr.car).to eq('c')
+
+          example = "(cons 'a 3)" # => (a . 3)
+          result = subject.run(example)
+          expect(result.car).to eq('a')
+          expect(result.cdr).to eq(3)
+
+          example = "(cons '(a b) 'c)" # => ((a b) . c)
+          result = subject.run(example)
+          expect(result.car).to be_kind_of(SkmPair)
+          expect(result.car.to_a).to eq(['a', 'b'])
+          expect(result.cdr).to be_kind_of(SkmIdentifier)
+          expect(result.cdr).to eq('c')
+        end
+
+        it 'should implement the car procedure' do
+          example = "(car '(a b c))" # => a
+          result = subject.run(example)
+          expect(result).to eq('a')
+
+          example = "(car '((a) b c d))" # => (a)
+          result = subject.run(example)
+          expect(result).to be_list
+          expect(result.length).to eq(1)
+          expect(result.car).to eq('a')
+
+          # example = "(car '(1 . 2))" # => 1 # FAILURE
+          # result = subject.run(example)
+          # expect(result.car).to eq(1)
+
+          example = "(car '())" # => error
+          expect { subject.run(example) }.to raise_error(StandardError)
+        end
+
+        it 'should implement the cdr procedure' do
+          example = "(cdr '((a) b c d))" # => (b c d)
+          result = subject.run(example)
+          expect(result).to be_list
+          expect(result.length).to eq(3)
+          expect(result.to_a).to eq(['b', 'c', 'd'])
+
+          # example = "(cdr '(1 . 2))" # => 2 # PARSER FAILURE
+          # result = subject.run(example)
+          # expect(result.cdr).to eq(2)
+
+          example = "(cdr '())" # => error
+          expect { subject.run(example) }.to raise_error(StandardError)
+        end
+
         it 'should implement the length procedure' do
           checks = [
             ['(length (list))', 0],
@@ -416,6 +503,17 @@ SKEEM
             expect(result).to eq(expectation)
           end
         end
+
+        it 'should implement the list->vector procedure' do
+          checks = [
+            ["(list->vector '())", []],
+            ["(list->vector '(a b c))", ['a', 'b', 'c']]
+          ]
+          checks.each do |(skeem_expr, expectation)|
+            result = subject.run(skeem_expr)
+            expect(result.to_a).to eq(expectation)
+          end
+        end
       end # context
 
       context 'Vector procedures:' do
@@ -467,6 +565,17 @@ SKEEM
           expect(result).to be_kind_of(SkmInteger)
           expect(result).to eq(8)
         end
+
+        it 'should implement the vector-> procedure' do
+          checks = [
+            ["(vector->list #())", []],
+            ["(vector->list '#(a b c))", ['a', 'b', 'c']]
+          ]
+          checks.each do |(skeem_expr, expectation)|
+            result = subject.run(skeem_expr)
+            expect(result.to_a).to eq(expectation)
+          end
+        end
       end # context
 
       context 'IO procedures:' do
@@ -478,7 +587,7 @@ SKEEM
           $stdout = default_stdout
         end
       end # context
-      
+
       context 'Miscellaneous procedures' do
         it 'should return true when an assertion succeeds' do
           source = <<-SKEEM
@@ -487,8 +596,8 @@ SKEEM
   (assert (> x y))
 SKEEM
           expect(subject.run(source).last).to eq(true)
-        end       
-      
+        end
+
         it 'should raise an error when an assertion fails' do
           source = <<-SKEEM
   (define x 1)
@@ -498,7 +607,7 @@ SKEEM
           err = StandardError
           msg = 'Error: assertion failed on line 3, column 4'
           expect { subject.run(source) }.to raise_error(err, msg)
-        end      
+        end
       end # context
     end # describe
   end # module

data/spec/skeem/s_expr_nodes_spec.rb

@@ -28,7 +28,7 @@ module Skeem
 
     context 'Provided services:' do
       include Primitive::PrimitiveBuilder
-      
+
       let(:runtime) { Runtime.new(Environment.new) }
 
       it 'should create an entry when evaluating' do
@@ -36,7 +36,7 @@ module Skeem
         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')
@@ -57,22 +57,22 @@ module Skeem
         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) 
+        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       
-      
+      end
+
       it 'should quasiquote its variable and expression' do
         alter_ego = subject.quasiquote(runtime)
-        expect(alter_ego).to eq(subject)        
+        expect(alter_ego).to eq(subject)
       end
 
       it 'should return its text representation' do
@@ -100,14 +100,14 @@ module Skeem
       end
 
       it 'should know its operands' do
-        expect(subject.operands.inspect).to eq('<Skeem::SkmList: 1, 2, 3>')
+        expect(subject.operands.inspect).to eq('<Skeem::SkmPair: 1, 2, 3>')
       end
     end # context
 
     context 'Provided services:' do
       it 'should return its text representation' do
         txt1 = '<Skeem::ProcedureCall: <Skeem::SkmIdentifier: +>, '
-        txt2 = '@operands <Skeem::SkmList: 1, 2, 3>>'
+        txt2 = '@operands <Skeem::SkmPair: 1, 2, 3>>'
         expect(subject.inspect).to eq(txt1 + txt2)
       end
     end # context

data/spec/skeem/skm_element_spec.rb

@@ -25,6 +25,7 @@ module Skeem
         expect(subject).not_to be_symbol
         expect(subject).not_to be_list
         expect(subject).not_to be_null
+        expect(subject).not_to be_pair
         expect(subject).not_to be_vector
       end
     end # context

data/spec/skeem/skm_empty_list_spec.rb

@@ -0,0 +1,44 @@
+require_relative '../spec_helper' # Use the RSpec framework
+require_relative '../../lib/skeem/skm_empty_list' # Load the class under test
+
+module Skeem
+  describe SkmEmptyList do
+    subject { SkmEmptyList.instance }
+
+    context 'Initialization:' do
+      it 'should be initialized without argument' do
+        expect { SkmEmptyList.instance }.not_to raise_error
+      end
+
+      # Default (overridable) behavior of SkmElement
+      it 'should react by default to predicates' do
+        expect(subject).to be_list
+        expect(subject).to be_null
+        expect(subject).not_to be_pair
+      end
+    end # context
+
+    context 'Provided services:' do
+      let(:runtime) { double('fake-runtime') }
+
+      it "should return itself when receiving 'evaluate' message" do
+        expect(subject.evaluate(runtime)).to eq(subject)
+      end
+
+      it "should return itself receiving 'quasiquote' message" do
+        expect(subject.quasiquote(runtime)).to eq(subject)
+      end
+
+      it "should reply to visitor's 'accept' message" do
+        visitor = double('fake-visitor')
+        expect(visitor).to receive(:visit_empty_list).with(subject)      
+        expect { subject.accept(visitor) }.not_to raise_error
+      end
+      
+      it 'should return its representation upon inspection' do
+        predicted = '<Skeem::SkmEmptyList: ()>'
+        expect(subject.inspect).to eq(predicted)
+      end
+    end # context
+  end # describe
+end # module

data/spec/skeem/skm_pair_spec.rb

@@ -0,0 +1,140 @@
+require_relative '../spec_helper' # Use the RSpec framework
+require_relative '../../lib/skeem/datum_dsl'
+require_relative '../../lib/skeem/runtime'
+require_relative '../../lib/skeem/skm_pair' # Load the class under test
+
+module Skeem
+  describe SkmPair do
+    include DatumDSL
+    let(:sample_car) { integer(3) }
+    let(:sample_cdr) { SkmEmptyList.instance }
+
+    # Default instance is proper list of length 1
+    subject { SkmPair.new(sample_car, sample_cdr) }
+
+    context 'Initialization:' do
+      it 'should be initialized with two arguments' do
+        expect { SkmPair.new(sample_car, sample_cdr) }.not_to raise_error
+      end
+
+      it "should know its 'car' field" do
+        expect(subject.car).to eq(sample_car)
+      end
+
+      it "should know its 'cdr' field" do
+        expect(subject.cdr).to eq(sample_cdr)
+      end
+
+      # Default (overridable) behavior of SkmElement
+      it 'should react by default to predicates' do
+        expect(subject).to be_list
+        expect(subject).not_to be_null
+        expect(subject).to be_pair
+      end
+    end # context
+
+    context 'Provided services:' do
+      let(:runtime) { Runtime.new(Environment.new) }
+      let(:list_length_2) { SkmPair.new(integer(10), subject) }
+      let(:quirk_element) { double('three') }
+      let(:quirk_members) { [integer(10), quirk_element] }
+
+      it 'should know its length' do
+        expect(subject.length).to eq(1)
+
+        # Use a list of length 2
+        expect(list_length_2.length).to eq(2)
+      end
+
+      it 'should convert itself into an array' do
+        expect(subject.to_a).to eq([sample_car])
+
+        # Use a list of length 2
+        expect(list_length_2.to_a).to eq([integer(10), sample_car])
+      end
+      
+      it 'should return the last element of a list' do
+         expect(subject.last).to eq(sample_car)
+         expect(list_length_2.last).to eq(sample_car)
+      end
+      
+      it 'should append a new element to a list' do
+        subject.append(integer(4))
+        expect(subject.length).to eq(2)
+        expect(subject.to_a).to eq([3, 4])
+      end
+
+      it 'should create a list from an array' do
+        # List of length 0
+        array0 = []
+        list = SkmPair.create_from_a(array0)
+        expect(list).to be_list # It's a proper list...
+        expect(list.length).to eq(0)
+        expect(list.to_a).to eq(array0)      
+      
+        # List of length 1
+        array1 = [boolean(false)]
+        list = SkmPair.create_from_a(array1)
+        expect(list).to be_list # It's a proper list...
+        expect(list.length).to eq(1)
+        expect(list.to_a).to eq(array1)
+
+        # List of length 2
+        array2 = [identifier('f'), identifier('g')]
+        list = SkmPair.create_from_a(array2)
+        expect(list).to be_list # It's a proper list...
+        expect(list.length).to eq(2)
+        expect(list.to_a).to eq(array2)
+
+        # List of length 3
+        array3 = [integer(4), integer(5), integer(6)]
+        list = SkmPair.create_from_a(array3)
+        expect(list).to be_list # It's a proper list...
+        expect(list.length).to eq(3)
+        expect(list.to_a).to eq([4, 5, 6])
+      end
+      
+      it 'should support the each method' do
+        my_list = SkmPair.new('w', SkmPair.new('o', SkmPair.new('w', SkmEmptyList.instance)))
+        text = ''
+        my_list.each { |ch| text << ch.upcase }
+        expect(text).to eq('WOW')
+      end
+
+      it 'should evaluate its members' do
+        # subject contains simple literals
+        expect(subject.evaluate(runtime)).to eq(subject)
+
+        # Check that members receive the 'evaluate' message
+        expect(quirk_element).to receive(:evaluate).with(runtime).and_return(integer(3))
+        instance = SkmPair.create_from_a(quirk_members)
+        expect { instance.evaluate(runtime) }.not_to raise_error
+      end
+
+      it 'should quasiquote its members' do
+        # subject contains simple literals
+        expect(subject.quasiquote(runtime)).to eq(subject)
+
+        # Check that members receive the 'quasiquote' message
+        expect(quirk_element).to receive(:quasiquote).with(runtime).and_return(integer(3))
+        instance = SkmPair.create_from_a(quirk_members)
+        expect { instance.quasiquote(runtime) }.not_to raise_error
+      end
+
+      it "should reply to visitor's 'accept' message" do
+        visitor = double('fake-visitor')
+        expect(visitor).to receive(:visit_pair).with(subject)
+        expect { subject.accept(visitor) }.not_to raise_error
+      end
+
+      it 'should return its representation upon inspection' do
+        predicted = '<Skeem::SkmPair: <Skeem::SkmInteger: 3>>'
+        expect(subject.inspect).to eq(predicted)
+
+        predicted = '<Skeem::SkmPair: <Skeem::SkmInteger: 10>, <Skeem::SkmInteger: 3>>'
+        expect(list_length_2.inspect).to eq(predicted)
+      end
+    end # context
+
+  end # describe
+end # module

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: skeem
 version: !ruby/object:Gem::Version
-  version: 0.0.28
+  version: 0.1.00
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-12-16 00:00:00.000000000 Z
+date: 2018-12-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley
@@ -98,7 +98,9 @@ files:
 - lib/skeem/s_expr_nodes.rb
 - lib/skeem/skm_compound_datum.rb
 - lib/skeem/skm_element.rb
+- lib/skeem/skm_empty_list.rb
 - lib/skeem/skm_expression.rb
+- lib/skeem/skm_pair.rb
 - lib/skeem/skm_simple_datum.rb
 - lib/skeem/skm_unary_expression.rb
 - lib/skeem/standard/base.skm
@@ -116,6 +118,8 @@ files:
 - spec/skeem/s_expr_nodes_spec.rb
 - spec/skeem/skm_compound_datum_spec.rb
 - spec/skeem/skm_element_spec.rb
+- spec/skeem/skm_empty_list_spec.rb
+- spec/skeem/skm_pair_spec.rb
 - spec/skeem/skm_simple_datum_spec.rb
 - spec/skeem/skm_unary_expression_spec.rb
 - spec/skeem/tokenizer_spec.rb
@@ -158,6 +162,8 @@ test_files:
 - spec/skeem/runtime_spec.rb
 - spec/skeem/skm_compound_datum_spec.rb
 - spec/skeem/skm_element_spec.rb
+- spec/skeem/skm_empty_list_spec.rb
+- spec/skeem/skm_pair_spec.rb
 - spec/skeem/skm_simple_datum_spec.rb
 - spec/skeem/skm_unary_expression_spec.rb
 - spec/skeem/s_expr_nodes_spec.rb