skeem 0.0.28 → 0.1.00

data/lib/skeem/s_expr_nodes.rb

@@ -1,8 +1,7 @@
 # Classes that implement nodes of Abstract Syntax Trees (AST) representing
 # Skeem parse results.
 
-require_relative 'skm_simple_datum'
-require_relative 'skm_compound_datum'
+require_relative 'datum_dsl'
 require_relative 'skm_unary_expression'
 
 module Skeem
@@ -46,6 +45,9 @@ module Skeem
       super(aPosition)
       @variable = aVariable
       @expression = theExpression
+      unless expression.kind_of?(SkmElement)
+        raise StandardError, "Bad definition"
+      end
     end
 
     def evaluate(aRuntime)
@@ -134,7 +136,11 @@ module Skeem
       else
         @operator = anOperator
       end
-      @operands = SkmList.new(theOperands)
+      if theOperands.nil?
+        @operands = SkmEmptyList.instance
+      else
+        @operands = SkmPair.create_from_a(theOperands)
+      end
       @operands_consumed = false
     end
 
@@ -313,6 +319,8 @@ module Skeem
   end # class
 
   class SkmLambda < SkmMultiExpression
+    include DatumDSL
+
     # @!attribute [r] formals
     # @return [Array<SkmIdentifier>] the argument names
     attr_reader :formals
@@ -377,7 +385,7 @@ module Skeem
     private
 
     def bind_locals(aRuntime, aProcedureCall)
-      actuals =  aProcedureCall.operands.members
+      actuals =  aProcedureCall.operands.to_a
       count_actuals = actuals.size
 
       if (count_actuals < required_arity) ||
@@ -392,12 +400,16 @@ module Skeem
           if actual.kind_of?(ProcedureCall)
             actual.evaluate(aRuntime)
           else
-            actual
+            to_datum(actual)
           end
         end
         variadic_arg_name = formals.formals.last
-        args_coll = SkmList.new(variadic_part)
+        args_coll = SkmPair.create_from_a(variadic_part)
         a_def = SkmDefinition.new(position, variadic_arg_name, args_coll)
+        # $stderr.puts "Tef #{a_def.inspect}"
+        # $stderr.puts "Tef #{actuals.inspect}"
+        # $stderr.puts "Tef #{variadic_part.inspect}"
+        # $stderr.puts "Tef #{aProcedureCall.inspect}"
         a_def.evaluate(aRuntime)
       end
       aProcedureCall.operands_consumed = true
@@ -423,7 +435,14 @@ module Skeem
               caller_index -= 1
             end
           else
-            result = cmd.evaluate(aRuntime)
+            begin
+              result = cmd.evaluate(aRuntime)
+            rescue NoMethodError => exc
+              $stderr.puts self.inspect
+              $stderr.puts sequence.inspect
+              $stderr.puts cmd.inspect
+              raise exc
+            end
           end
         end
       end
@@ -434,14 +453,22 @@ module Skeem
     # Purpose: bind each formal from lambda to an actual value from the call
     def bind_required_locals(aRuntime, aProcedureCall)
       max_index = required_arity - 1
-      actuals =  aProcedureCall.operands.members
+      case aProcedureCall.operands
+        when SkmPair
+          actuals =  aProcedureCall.operands.to_a
+        when SkmEmptyList
+          actuals = []
+        else
+          raise StandardError, "Unsupported type of operand list #{aProcedureCall.operands.inspect}"
+          actuals =  aProcedureCall.operands.members
+      end
       formal_names = formals.formals.map(&:value)
 
       formals.formals.each_with_index do |arg_name, index|
         arg = actuals[index]
         if arg.nil?
           if actuals.empty? && formals.variadic?
-            arg = SkmList.new([])
+            arg = SkmPair.create_from_a([])
           else
             raise StandardError, "Unbound variable: '#{arg_name.value}'"
           end
@@ -449,6 +476,9 @@ module Skeem
 
         # IMPORTANT: execute procedure call in argument list now
         arg = arg.evaluate(aRuntime) if arg.kind_of?(ProcedureCall)
+        unless arg.kind_of?(SkmElement)
+          arg = to_datum(arg)
+        end
         a_def = SkmDefinition.new(position, arg_name, arg)
         # $stderr.puts "Procedure call #{aProcedureCall.operator.inspect}"
         # $stderr.puts "LOCAL #{arg_name.value} #{arg.inspect}"

data/lib/skeem/skm_compound_datum.rb

@@ -26,7 +26,7 @@ module Skeem
           members == other
       end
     end
-    
+
     alias eqv? equal?
 
     def evaluate(aRuntime)
@@ -58,6 +58,7 @@ module Skeem
     end
   end # class
 
+  # @deprecated Use {#SkmPair} class instead.
   class SkmList < SkmCompoundDatum
     def tail()
       SkmList.new(members.slice(1..-1))
@@ -70,7 +71,7 @@ module Skeem
     def null?
       empty?
     end
-    
+
     def evaluate(aRuntime)
       if empty?
         self.class.new(nil)

data/lib/skeem/skm_element.rb

@@ -36,6 +36,10 @@ module Skeem
     def null?
       false
     end
+    
+    def pair?
+      false
+    end
 
     def vector?
       false

data/lib/skeem/skm_empty_list.rb

@@ -0,0 +1,60 @@
+require 'singleton'
+require_relative 'skm_element'
+
+module Skeem
+  # From R7RS: The empty list is a special object of its own type. 
+  # It is not a pair, it has no elements, and its length is zero.
+  class SkmEmptyList < SkmElement
+    include Singleton
+
+    def list?
+      true
+    end
+
+    def null?
+      true
+    end
+    
+    def pair?
+      false
+    end
+    
+    def length
+      0
+    end
+    
+    def to_a
+      []
+    end
+    
+    def empty?
+      true
+    end
+
+    def evaluate(_runtime)
+      self
+    end
+
+    def quasiquote(_runtime)
+      self
+    end
+
+    # Part of the 'visitee' role in Visitor design pattern.
+    # @param _visitor [SkmElementVisitor] the visitor
+    def accept(aVisitor)
+      aVisitor.visit_empty_list(self)
+    end
+
+    protected
+
+    def inspect_specific
+      '()'
+    end
+
+    private
+
+    def initialize()
+      super(0)
+    end
+  end # class
+end # module

data/lib/skeem/skm_pair.rb

@@ -0,0 +1,126 @@
+require_relative 'skm_empty_list'
+
+module Skeem
+  class SkmPair < SkmElement
+    attr_accessor :car
+    attr_accessor :cdr
+    
+    alias first car
+    alias members to_a
+
+    def initialize(head, tail)
+      super(0)
+      @car = head
+      @cdr = tail
+    end
+
+    def self.create_from_a(anArray)
+      current = nil
+      return SkmEmptyList.instance if anArray.empty?
+      anArray.reverse_each do |elem|
+        if current.nil?
+          current = self.new(elem, SkmEmptyList.instance)
+        else
+          current = self.new(elem, current)
+        end
+      end
+
+      current
+    end
+    
+    def empty?
+      return false if car
+      if [SkmPair, SkmEmptyList].include? cdr.class
+        cdr.empty? 
+      else
+        false
+      end
+    end
+
+    def list?
+      if cdr.nil?
+        false
+      else
+        cdr.list?
+      end
+    end
+
+    def pair?
+      true
+    end
+
+    def length
+      if [SkmPair, SkmEmptyList].include?(cdr.class)
+        cdr.length + 1
+      else
+        raise StandardError, 'Improper list'
+      end
+    end
+    
+    def to_a
+      result = [car]
+      if cdr && !cdr.null?
+        result.concat(cdr.to_a)
+      end
+
+      result    
+    end
+    
+    def last
+      self.to_a.last
+    end
+    
+    def each(&aBlock)
+      aBlock.call(car)
+      cdr.each(&aBlock) if cdr && !cdr.null?
+    end
+    
+    def append(anElement)
+      if cdr.nil? || cdr.kind_of?(SkmEmptyList)
+        self.cdr = SkmPair.new(anElement, SkmEmptyList.instance)
+      elsif cdr.kind_of?(SkmPair)
+        self.cdr.append(anElement)
+      else
+        raise StandardError, "Cannot append #{anElement.inspect}"
+      end
+    end
+
+    def evaluate(aRuntime)
+      return SkmEmptyList.instance if empty?
+      if car.kind_of?(SkmIdentifier)
+        result = aRuntime.evaluate_form(self)
+      else
+        members_eval = self.to_a.map { |elem| elem.evaluate(aRuntime) }
+        result = self.class.create_from_a(members_eval)
+      end
+      result
+    end
+
+    def quasiquote(aRuntime)
+      members_eval = self.to_a.map { |elem| elem.quasiquote(aRuntime) }
+      self.class.create_from_a(members_eval)  
+    end   
+
+    # Part of the 'visitee' role in Visitor design pattern.
+    # @param _visitor [SkmElementVisitor] the visitor
+    def accept(aVisitor)
+      aVisitor.visit_pair(self)
+    end
+    
+    def done!()
+      # Do nothing
+    end
+
+    protected
+
+    def inspect_specific
+      result = car.inspect
+      if cdr && !cdr.null?
+        result << ', ' << cdr.send(:inspect_specific)
+      end
+
+      result
+    end
+
+  end # class
+end # module

data/lib/skeem/skm_simple_datum.rb

@@ -81,8 +81,7 @@ module Skeem
       value.to_s
     end
   end # class
-
-
+  
   class SkmBoolean < SkmSimpleDatum
     def boolean?
       true

data/lib/skeem/standard/base.skm

@@ -72,6 +72,30 @@
 ; Allocates and returns a new list from its arguments   
 (define list
   (lambda args args))
+ 
+; (define caar 
+  ; (lambda (x)
+    ; (car (car x))))
 
+; (define cadr 
+  ; (lambda (x) 
+    ; (car (cdr x))))
 
+;(define cdar 
+;  (lambda(x)
+;    (cdr (car x))))
+
+;(define cddr 
+;  (lambda (x) 
+;    (cdr (cdr x))))
+
+;; (list-ref list n)    
+;; Return the nth (sero-based) element of list
+;; n must be a nonnegative integer
+;(define list-ref
+;  (lambda (ls n)
+;    (if (= n 0)
+;        (car ls)
+;        (list-ref (cdr ls) (- n 1))))) 
+ 
 (define symbol=? string=?)

data/lib/skeem/version.rb

@@ -1,3 +1,3 @@
 module Skeem
-  VERSION = '0.0.28'.freeze
+  VERSION = '0.1.00'.freeze
 end

data/spec/skeem/datum_dsl_spec.rb

@@ -24,7 +24,7 @@ module Skeem
         ['false', false]
       ]
     end
-    
+
     let(:integer_tests) do
       [
         [0, 0],
@@ -33,10 +33,10 @@ module Skeem
         ['0', 0],
         ['-123', -123],
         ['+456', 456]
-      ]      
+      ]
     end
 
-    let(:real_tests) do    
+    let(:real_tests) do
       [
         [0, 0],
         [-123.4, -123.4],
@@ -48,18 +48,18 @@ module Skeem
         ['-1.234e+3', -1234]
       ]
     end
-    
-    let(:string_tests) do    
+
+    let(:string_tests) do
       [
         ['hello', 'hello']
-      ]    
+      ]
     end
-    
-    let(:identifier_tests) do    
+
+    let(:identifier_tests) do
       [
         ['define', 'define'],
         [SkmString.create('positive?'), 'positive?']
-      ]    
+      ]
     end
 
     let(:simple_datum_tests) do
@@ -102,38 +102,38 @@ module Skeem
         end
       end
     end # context
-    
-    
+
+
     context 'Compound datums:' do
-      it 'should convert empty array into one-member list' do 
+      it 'should convert empty array into one-member list' do
         result = subject.list([])
-        expect(result).to be_kind_of(SkmList)
-        expect(result).to be_null      
+        expect(result).to be_kind_of(SkmEmptyList)
+        expect(result).to be_null
       end
-      
+
       it 'should convert array of simple datums into list' do
         literals = simple_datum_tests.map { |(datum, _predicted)| datum }
         predictions = simple_datum_tests.map { |(_datum, predicted)| predicted }
         list_result = subject.list(literals)
-        expect(list_result).to be_kind_of(SkmList)
-        list_result.members.each_with_index do |member, index|
+        expect(list_result).to be_kind_of(SkmPair)
+        list_result.to_a.each_with_index do |member, index|
           expect(member).to eq(predictions[index])
         end
       end
-      
-      it 'should convert a single datum into one-member list' do 
+
+      it 'should convert a single datum into one-member list' do
         result = subject.list('123')
-        expect(result).to be_kind_of(SkmList)
-        expect(result.members.first).to eq(123)
-      end      
-      
-      it 'should convert empty array into one-member list' do 
+        expect(result).to be_kind_of(SkmPair)
+        expect(result.car).to eq(123)
+      end
+
+      it 'should convert empty array into one-member list' do
         result = subject.vector([])
         expect(result).to be_kind_of(SkmVector)
-        expect(result.members).to be_empty     
+        expect(result.members).to be_empty
       end
-    
-      
+
+
       it 'should convert array of simple datums into vector' do
         literals = simple_datum_tests.map { |(datum, _predicted)| datum }
         predictions = simple_datum_tests.map { |(_datum, predicted)| predicted }
@@ -144,11 +144,11 @@ module Skeem
         end
       end
 
-      it 'should convert a single datum into one-member vector' do 
+      it 'should convert a single datum into one-member vector' do
         result = subject.vector('123')
         expect(result).to be_kind_of(SkmVector)
         expect(result.members.first).to eq(123)
-      end      
+      end
     end # context
 
     context 'Arbitrary datums:' do
@@ -157,7 +157,7 @@ module Skeem
           expect(subject.to_datum(literal)).to eq(predicted)
         end
       end
-      
+
       it 'should recognize & convert integer literals' do
         integer_tests.each do |(literal, predicted)|
           expect(subject.to_datum(literal)).to eq(predicted)
@@ -178,14 +178,26 @@ module Skeem
 
       it 'should convert nested compound datums' do
         literals = [
-          'false', '123', '-1.41', 
+          'false', '123', '-1.41',
           'foo', SkmVector.new(['uno', '2', 3.0]), 'bar'
         ]
         result = subject.list(literals)
-        expect(result).to be_kind_of(SkmList)
-        expect(result).to eq([false, 123, -1.41, 'foo', ['uno', 2, 3], 'bar'])
+        expect(result).to be_kind_of(SkmPair)
+        expect(result.to_a).to eq([false, 123, -1.41, 'foo', ['uno', 2, 3], 'bar'])
       end
     end
 
+    it 'should duplicate a given list' do
+      f = subject.identifier('f')
+      g = subject.identifier('g')
+      one_list = subject.list([f, g])
+      expect(one_list).to be_list
+      expect(one_list.to_a).to eq([f, g])
+      duplicate = subject.to_datum(one_list)
+      expect(duplicate).to be_list
+      # $stderr.puts duplicate.inspect
+      expect(duplicate.to_a).to eq([f, g])
+    end
+
   end # describe
 end # module

data/spec/skeem/element_visitor_spec.rb

@@ -75,16 +75,32 @@ module Skeem
         ls = list ['#false', 3, 'foo']
         instance = SkmElementVisitor.new(ls)
         instance.subscribe(listener)
-        expect(listener).to receive(:before_compound_datum).with(runtime, ls).ordered
-        expect(listener).to receive(:before_children).with(runtime, ls, ls.members).ordered
-        expect(listener).to receive(:before_simple_datum).with(runtime, ls.members[0]).ordered
-        expect(listener).to receive(:after_simple_datum).with(runtime, ls.members[0]).ordered
-        expect(listener).to receive(:before_simple_datum).with(runtime, ls.members[1]).ordered
-        expect(listener).to receive(:after_simple_datum).with(runtime, ls.members[1]).ordered
-        expect(listener).to receive(:before_simple_datum).with(runtime, ls.members[2]).ordered
-        expect(listener).to receive(:after_simple_datum).with(runtime, ls.members[2]).ordered
-        expect(listener).to receive(:after_children).with(runtime, ls, ls.members).ordered
-        expect(listener).to receive(:after_compound_datum).with(runtime, ls).ordered
+        expect(listener).to receive(:before_pair).with(runtime, ls).ordered
+        expect(listener).to receive(:before_car).with(runtime, ls, ls.car).ordered
+        expect(listener).to receive(:before_simple_datum).with(runtime, ls.car).ordered
+        expect(listener).to receive(:after_simple_datum).with(runtime, ls.car).ordered
+        expect(listener).to receive(:after_car).with(runtime, ls, ls.car).ordered
+        expect(listener).to receive(:before_cdr).with(runtime, ls, ls.cdr).ordered
+        expect(listener).to receive(:before_pair).with(runtime, ls.cdr).ordered
+        expect(listener).to receive(:before_car).with(runtime, ls.cdr, ls.cdr.car).ordered
+        expect(listener).to receive(:before_simple_datum).with(runtime, ls.cdr.car).ordered
+        expect(listener).to receive(:after_simple_datum).with(runtime, ls.cdr.car).ordered
+        expect(listener).to receive(:after_car).with(runtime, ls.cdr, ls.cdr.car).ordered
+        expect(listener).to receive(:before_cdr).with(runtime, ls.cdr, ls.cdr.cdr).ordered
+        expect(listener).to receive(:before_pair).with(runtime, ls.cdr.cdr).ordered
+        expect(listener).to receive(:before_car).with(runtime, ls.cdr.cdr, ls.cdr.cdr.car).ordered
+        expect(listener).to receive(:before_simple_datum).with(runtime, ls.cdr.cdr.car).ordered
+        expect(listener).to receive(:after_simple_datum).with(runtime, ls.cdr.cdr.car).ordered
+        expect(listener).to receive(:after_car).with(runtime, ls.cdr.cdr, ls.cdr.cdr.car).ordered
+        expect(listener).to receive(:before_cdr).with(runtime, ls.cdr.cdr, ls.cdr.cdr.cdr).ordered
+        expect(listener).to receive(:before_empty_list).with(runtime, ls.cdr.cdr.cdr).ordered
+        expect(listener).to receive(:after_empty_list).with(runtime, ls.cdr.cdr.cdr).ordered
+        expect(listener).to receive(:after_cdr).with(runtime, ls.cdr.cdr, ls.cdr.cdr.cdr).ordered
+        expect(listener).to receive(:after_pair).with(runtime, ls.cdr.cdr).ordered
+        expect(listener).to receive(:after_cdr).with(runtime, ls.cdr, ls.cdr.cdr).ordered
+        expect(listener).to receive(:after_pair).with(runtime, ls.cdr).ordered
+        expect(listener).to receive(:after_cdr).with(runtime, ls, ls.cdr).ordered
+        expect(listener).to receive(:after_pair).with(runtime, ls).ordered
         instance.start(runtime)
       end
 
@@ -116,55 +132,40 @@ module Skeem
         expect(listener).to receive(:after_simple_datum).with(runtime, vec.members[0]).ordered
         expect(listener).to receive(:before_simple_datum).with(runtime, vec.members[1]).ordered
         expect(listener).to receive(:after_simple_datum).with(runtime, vec.members[1]).ordered
-        expect(listener).to receive(:before_compound_datum).with(runtime, vec.members[2]).ordered
-        expect(listener).to receive(:before_children).with(runtime, nested_list, nested_list.members).ordered
-        expect(listener).to receive(:before_simple_datum).with(runtime, nested_list.members[0]).ordered
-        expect(listener).to receive(:after_simple_datum).with(runtime, nested_list.members[0]).ordered
-        expect(listener).to receive(:before_simple_datum).with(runtime, nested_list.members[1]).ordered
-        expect(listener).to receive(:after_simple_datum).with(runtime, nested_list.members[1]).ordered
-        expect(listener).to receive(:before_simple_datum).with(runtime, nested_list.members[2]).ordered
-        expect(listener).to receive(:after_simple_datum).with(runtime, nested_list.members[2]).ordered
-        expect(listener).to receive(:after_children).with(runtime, nested_list, nested_list.members).ordered
-        expect(listener).to receive(:after_compound_datum).with(runtime, nested_list).ordered
+        
+        expect(listener).to receive(:before_pair).with(runtime, nested_list).ordered
+        expect(listener).to receive(:before_car).with(runtime, nested_list, nested_list.car).ordered
+        expect(nested_list.car).to eq('uno')
+        expect(listener).to receive(:before_simple_datum).with(runtime, nested_list.car).ordered
+        expect(listener).to receive(:after_simple_datum).with(runtime, nested_list.car).ordered
+        expect(listener).to receive(:after_car).with(runtime, nested_list, nested_list.car).ordered
+        expect(listener).to receive(:before_cdr).with(runtime, nested_list, nested_list.cdr).ordered
+        expect(listener).to receive(:before_pair).with(runtime, nested_list.cdr).ordered
+        expect(listener).to receive(:before_car).with(runtime, nested_list.cdr, nested_list.cdr.car).ordered
+        expect(listener).to receive(:before_simple_datum).with(runtime, nested_list.cdr.car).ordered
+        expect(listener).to receive(:after_simple_datum).with(runtime, nested_list.cdr.car).ordered
+        expect(listener).to receive(:after_car).with(runtime, nested_list.cdr, nested_list.cdr.car).ordered
+        expect(listener).to receive(:before_cdr).with(runtime, nested_list.cdr, nested_list.cdr.cdr).ordered
+        expect(listener).to receive(:before_pair).with(runtime, nested_list.cdr.cdr).ordered
+        expect(listener).to receive(:before_car).with(runtime, nested_list.cdr.cdr, nested_list.cdr.cdr.car).ordered
+        expect(listener).to receive(:before_simple_datum).with(runtime, nested_list.cdr.cdr.car).ordered
+        expect(listener).to receive(:after_simple_datum).with(runtime, nested_list.cdr.cdr.car).ordered
+        expect(listener).to receive(:after_car).with(runtime, nested_list.cdr.cdr, nested_list.cdr.cdr.car).ordered
+        expect(listener).to receive(:before_cdr).with(runtime, nested_list.cdr.cdr, nested_list.cdr.cdr.cdr).ordered
+        expect(listener).to receive(:before_empty_list).with(runtime, nested_list.cdr.cdr.cdr).ordered
+        expect(listener).to receive(:after_empty_list).with(runtime, nested_list.cdr.cdr.cdr).ordered
+        expect(listener).to receive(:after_cdr).with(runtime, nested_list.cdr.cdr, nested_list.cdr.cdr.cdr).ordered
+        expect(listener).to receive(:after_pair).with(runtime, nested_list.cdr.cdr).ordered
+        expect(listener).to receive(:after_cdr).with(runtime, nested_list.cdr, nested_list.cdr.cdr).ordered
+        expect(listener).to receive(:after_pair).with(runtime, nested_list.cdr).ordered
+        expect(listener).to receive(:after_cdr).with(runtime, nested_list, nested_list.cdr).ordered
+        expect(listener).to receive(:after_pair).with(runtime, nested_list).ordered        
         expect(listener).to receive(:before_simple_datum).with(runtime, vec.members[3]).ordered
         expect(listener).to receive(:after_simple_datum).with(runtime, vec.members[3]).ordered
         expect(listener).to receive(:after_children).with(runtime, vec, vec.members).ordered
         expect(listener).to receive(:after_compound_datum).with(runtime, vec).ordered
         instance.start(runtime)
       end
-
-      # it 'should allow the visit of list datum object' do
-        # subject.subscribe(listener)
-        # expect(listener).to receive(:before_compound_datum).with(runtime, simple_datum)
-        # expect(listener).to receive(:after_compound_datum).with(runtime, simple_datum)
-        # subject.start(runtime)
-        # expect(subject.runtime).to eq(runtime)
-      # end
     end # context
-
-=begin
-      it 'should react to the start_visit_nonterminal message' do
-        # Notify subscribers when start the visit of a non-terminal node
-        expect(listener1).to receive(:before_non_terminal).with(nterm_node)
-        subject.visit_nonterminal(nterm_node)
-      end
-
-      it 'should react to the visit_children message' do
-        # Notify subscribers when start the visit of children nodes
-        children = nterm_node.subnodes
-        args = [nterm_node, children]
-        expect(listener1).to receive(:before_subnodes).with(*args)
-        expect(listener1).to receive(:before_terminal).with(children[0])
-        expect(listener1).to receive(:after_terminal).with(children[0])
-        expect(listener1).to receive(:after_subnodes).with(nterm_node, children)
-        subject.send(:traverse_subnodes, nterm_node)
-      end
-
-      it 'should react to the end_visit_nonterminal message' do
-        # Notify subscribers when ending the visit of a non-terminal node
-        expect(listener1).to receive(:after_non_terminal).with(nterm_node)
-        subject.end_visit_nonterminal(nterm_node)
-      end
-=end
   end # describe
 end # module