skeem 0.1.03 → 0.2.00

data/lib/skeem/skm_binding.rb

@@ -0,0 +1,103 @@
+require_relative 'skm_element'
+
+module Skeem
+  
+  # An identifier that is not a syntactic keyword can be used as a variable.
+  # A variable may give a name to value that is bound (i.e. associated)
+  # to that variable.
+  class SkmBinding < SkmElement
+    # @return [SkmIdentifier] The identifier that is bound the value.
+    attr_reader(:variable)
+    
+    # @return [SkmElement] The Skeem object that is associated with the variable.
+    attr_reader(:value)
+    
+    # Constructor
+    # @param anIdentifier [SkmIdentifier] The variable name
+    # @param aValue [SkmElement] The value to bind to the variable.
+    def initialize(anIdentifier, aValue)
+      @variable = anIdentifier
+      @value = aValue
+    end
+    
+    def evaluate(aRuntime)
+      name = variable.evaluate(aRuntime)
+
+      if value.kind_of?(SkmVariableReference)
+        other_name = value.variable.evaluate(aRuntime)
+        if name.value != other_name.value
+          entry = aRuntime.fetch(other_name)
+          result = value.evaluate(aRuntime)
+          if entry.callable?
+            @value = entry
+          end
+        else
+          # same name in definiens
+          raise StandardError
+        end
+      else
+        result = value.evaluate(aRuntime)
+      end
+      
+=begin      
+      aRuntime.add_binding(var_key, self)
+      case expression
+        when SkmLambda
+          result = expression.evaluate(aRuntime)
+
+        when SkmVariableReference
+          other_key = expression.variable.evaluate(aRuntime)
+          if var_key.value != other_key.value
+            entry = aRuntime.fetch(other_key)
+            result = expression.evaluate(aRuntime)
+            if entry.kind_of?(Primitive::PrimitiveProcedure)
+              @expression = entry
+            elsif entry.kind_of?(SkmDefinition)
+              if entry.expression.kind_of?(SkmLambda)
+                @expression = entry.expression
+              end
+            end
+          else
+            # INFINITE LOOP DANGER: definition of 'x' has a reference to 'x'!
+            # Way out: the lookup for the reference should start from outer
+            # environment.
+            env = aRuntime.pop
+            @expression = expression.evaluate(aRuntime)
+            aRuntime.push(env)
+            result = expression
+          end
+        else
+          result = self
+      end
+=end
+      binding_action(aRuntime, name, result)
+      result
+    end
+    
+    protected
+    
+    def binding_action(aRuntime, anIdentifier, anExpression)
+      aRuntime.add_binding(anIdentifier, anExpression)
+    end
+
+    def inspect_specific
+      result = variable.inspect
+      if value
+        result << ', ' << value.inspect
+      end
+
+      result
+    end    
+    
+  end # class
+  
+
+  class SkmUpdateBinding < SkmBinding
+  
+    protected
+    
+    def binding_action(aRuntime, anIdentifier, anExpression)
+      aRuntime.update_binding(anIdentifier, anExpression)
+    end    
+  end # class
+end # module

data/lib/skeem/skm_element.rb

@@ -4,6 +4,10 @@ module Skeem
     def initialize(aPosition)
       self.position = aPosition
     end
+    
+    def callable?
+      false
+    end
 
     def number?
       false
@@ -36,7 +40,7 @@ module Skeem
     def null?
       false
     end
-    
+
     def pair?
       false
     end
@@ -44,16 +48,16 @@ module Skeem
     def vector?
       false
     end
-    
+
     def eqv?(other)
       equal?(other)
     end
-    
+
     def skm_equal?(_other)
       msg = "Missing implementation of method #{self.class.name}##{__method__}"
       raise NotImplementedError, msg
     end
-    
+
     # @return [TrueClass, FalseClass] true if quoted element is identical to itself
     def verbatim?
       false
@@ -62,10 +66,10 @@ module Skeem
     def evaluate(_runtime)
       raise NotImplementedError, "Missing implementation of #{self.class.name}"
     end
-    
+
     def quasiquote(_runtime)
       raise NotImplementedError, "Missing implementation of #{self.class.name}"
-    end    
+    end
 
     # Abstract method.
     # Part of the 'visitee' role in Visitor design pattern.
@@ -77,14 +81,20 @@ module Skeem
     def done!
       # Do nothing
     end
-    
+
     def quoted!
       # Do nothing
     end
-    
+
     def unquoted!
       # Do nothing
-    end    
+    end
+
+    # Notification that this procedure is bound to a variable
+    # @param [Skemm::SkmFrame]
+    def bound!(_frame)
+      # Do nothing
+    end
 
    def inspect
       result = inspect_prefix
@@ -105,7 +115,7 @@ module Skeem
     end
 
     def inspect_specific
-      raise NotImplementedError
+      raise NotImplementedError, "Missing #{self.class.to_s + '#' + 'inspect_specific'}"
     end
   end # struct
 end # module

data/lib/skeem/skm_frame.rb

@@ -0,0 +1,137 @@
+require_relative 'skm_simple_datum'
+
+module Skeem
+  # A frame is a set of bindings of the form { String => SkmElement }.
+  # It associate to each identifier (as String) a Skeem object.
+  class SkmFrame
+    # @return [SkmFrame, nil] Link to parent frame (if any).
+    attr_reader :parent
+
+    # @return [Hash{String => SkmElement}] Map of variable names => values.
+    attr_reader(:bindings)
+
+    # Constructor
+    # @param parentFrame[SkmFrame] Parent frame of this one.
+    def initialize(parentFrame = nil)
+      @bindings = {}
+      @parent = parentFrame
+    end
+    
+    # Add a binding to this frame.
+    # There is no check that the variable name is already in use.
+    # @param anIdentifier [String, SkmIdentifier] The variable name
+    # @param anExpression [SkmElement] The Skeem expression to bind
+    def add_binding(anIdentifier, anExpression)
+      bind(valid_identifier(anIdentifier), anExpression)
+    end
+
+    # Update the value of an existing variable.
+    # @param anIdentifier [String, SkmIdentifier] The variable name.
+    # @param anExpression [SkmElement] The Skeem expression to bind
+    def update_binding(anIdentifier, anExpression)
+      variable = valid_identifier(anIdentifier) 
+      if bindings.include?(variable)
+        bind(variable, anExpression)
+      elsif parent
+        parent.update_binding(variable, anExpression)
+      end
+    end
+
+    # Retrieve the value of an existing variable.
+    # @param anIdentifier [String, SkmIdentifier] The variable name.
+    # @return [SkmElement]
+    def fetch(anIdentifier)
+      variable = valid_identifier(anIdentifier)
+      found = bindings[variable]
+      if found.nil? && parent
+        found = parent.fetch(variable)
+      end
+
+      found
+    end
+
+    # Tell  the value of an existing variable.
+    # @param anIdentifier [String, SkmIdentifier] The variable name.
+    # @return [Boolean]    
+    def include?(anIdentifier)
+      variable = valid_identifier(anIdentifier)
+      my_result = bindings.include?(variable)
+      if my_result == false && parent
+        my_result = parent.include?(variable)
+      end
+
+      my_result
+    end
+
+    # @return [Boolean]
+    def empty?
+      my_result = bindings.empty?
+      if my_result && parent
+        my_result = parent.empty?
+      end
+
+      my_result
+    end
+
+    # @return [Integer]
+    def size
+      my_result = bindings.size
+      my_result += parent.size if parent
+
+      my_result
+    end
+
+    # The number of parents this frame has.
+    # @return [Integer] The nesting levels
+    def depth
+      count = 0
+
+      curr_frame = self
+      while curr_frame.parent
+        count += 1
+        curr_frame = curr_frame.parent
+      end
+
+      count
+    end
+
+    # @return [String]
+    def inspect
+      result = ''
+      if parent
+        result << parent.inspect
+      else
+        return "\n"
+      end
+      result << "\n----\n"
+      bindings.each_pair do |key, expr|
+        result << "#{key.inspect} => #{expr.inspect}\n"
+      end
+
+      result
+    end
+    
+    private
+    
+    def valid_identifier(anIdentifier)
+      case anIdentifier
+        when String
+          anIdentifier
+        when SkmIdentifier
+          anIdentifier.value
+        else
+          klass = anIdentifier.class.to_s
+          err_msg = "Invalid identifier: #{anIdentifier} has type #{klass}."
+          raise StandardError, err_msg
+      end
+    end
+    
+    def bind(anIdentifier, anExpression)
+      @bindings[anIdentifier] = anExpression
+      
+      # Notify the value that it is bound to a variable from this frame.
+      anExpression.bound!(self)    
+    end
+    
+  end # class
+end # module

data/lib/skeem/skm_pair.rb

@@ -133,8 +133,8 @@ module Skeem
         begin
           result = clone_evaluate(aRuntime)
         rescue NoMethodError => exc
-          $stderr.puts self.inspect
-          $stderr.puts self.to_a.inspect
+          $stderr.puts 'SkmPair#evaluate:   ' + self.inspect
+          $stderr.puts 'SkmPair as Array:   ' + self.to_a.inspect
           raise exc
         end
       end

data/lib/skeem/skm_procedure_exec.rb

@@ -0,0 +1,31 @@
+require_relative 'runtime'
+
+module Skeem
+  class SkmProcedureExec
+    attr_reader :frame
+    attr_reader :definition
+
+    def initialize(aLambda)
+      @definition = aLambda
+      @frame = SkmFrame.new(definition.environment)
+      # $stderr.puts "New SkmProcedureExec"
+      # $stderr.puts "  frame = #{frame.object_id.to_s(16)}"
+      # $stderr.puts "  Lambda = #{aLambda.object_id.to_s(16)}"
+    end
+
+    # @param theActuals [Array<SkmElement>]
+    def run!(aRuntime, theActuals)
+      runtime = aRuntime
+      runtime.push(frame)
+      definition.bind_locals(runtime, theActuals)
+      # $stderr.puts "Locals"
+      # $stderr.puts frame.bindings.keys.join(', ')
+      definition.evaluate_defs(runtime)
+      result = definition.evaluate_sequence(runtime)
+      runtime.pop
+      # $stderr.puts "Lambda result: #{result.object_id.to_s(16)}" if result.kind_of?(SkmLambda)
+      
+      result
+    end
+  end # class
+end # module

data/lib/skeem/standard/base.skm

@@ -98,4 +98,18 @@
 ;        (car ls)
 ;        (list-ref (cdr ls) (- n 1))))) 
  
-(define symbol=? string=?)
+(define symbol=? string=?)
+
+;; Test the equivalence (with eqv? predicate) between an expected value and
+;; an expression
+;; (test-eqv expected test-expr)
+(define test-eqv 
+  (lambda (x y) 
+    (test-assert (equal? x y))))
+
+;; Test the equality (with equal? predicate) between an expected value and
+;; an expression
+;; (test-equal expected test-expr)
+(define test-equal 
+  (lambda (x y) 
+    (test-assert (equal? x y))))

data/lib/skeem/tokenizer.rb

@@ -29,7 +29,7 @@ module Skeem
       '#(' => 'VECTOR_BEGIN'
     }.freeze
 
-    # Here are all the SRL keywords (in uppercase)
+    # Here are all the Scheme keywords (in uppercase)
     @@keywords = %w[
       BEGIN
       DEFINE
@@ -37,6 +37,7 @@ module Skeem
       LAMBDA
       QUASIQUOTE
       QUOTE
+      SET!
       UNQUOTE
       UNQUOTE-SPLICING
     ].map { |x| [x, x] } .to_h

data/lib/skeem/version.rb

@@ -1,3 +1,3 @@
 module Skeem
-  VERSION = '0.1.03'.freeze
+  VERSION = '0.2.00'.freeze
 end

data/spec/skeem/interpreter_spec.rb

@@ -8,8 +8,12 @@ module Skeem
     include DatumDSL
 
     context 'Initialization:' do
-      it 'should be initialized without argument' do
-        expect { Interpreter.new() }.not_to raise_error
+      it 'could be initialized without an argument' do
+        expect { Interpreter.new }.not_to raise_error
+      end
+
+      it 'could be initialized with a block argument' do
+        expect { Interpreter.new { |interp| }  }.not_to raise_error
       end
 
       it 'should have a parser' do
@@ -26,8 +30,9 @@ module Skeem
 
       it 'should implement base bindings' do
         expect(subject.fetch('number?')).to be_kind_of(Primitive::PrimitiveProcedure)
-        expect(subject.fetch('abs')).to be_kind_of(SkmDefinition)
-        expect(subject.fetch('abs').expression).to be_kind_of(SkmLambda)
+        expect(subject.fetch('abs')).to be_kind_of(SkmLambda)
+        expect(subject.fetch('abs').formals.arity).to eq(1)
+        expect(subject.fetch('abs').formals.formals[0]).to eq('x')
       end
     end # context
 
@@ -107,7 +112,7 @@ module Skeem
     context 'Built-in primitives' do
       it 'should implement variable definition' do
         result = subject.run('(define x 28)')
-        expect(result).to be_kind_of(SkmDefinition)
+        expect(subject.fetch('x')).to eq(28)
       end
 
       it 'should implement variable reference' do
@@ -125,7 +130,7 @@ SKEEM
       it 'should implement the simple conditional form' do
          checks = [
           ['(if (> 3 2) "yes")', 'yes'],
-          ['(if (> 2 3) "yes")', :UNDEFINED]
+          ['(if (> 2 3) "yes")', SkmUndefined.instance]
         ]
         checks.each do |(skeem_expr, expectation)|
           result = subject.run(skeem_expr)
@@ -213,7 +218,7 @@ SKEEM
       (if (< x 0) (- x) x)))
 SKEEM
         subject.run(source)
-        procedure = subject.fetch('abs').expression
+        procedure = subject.fetch('abs')
         expect(procedure.arity).to eq(1)
         result = subject.run('(abs -3)')
         expect(result).to eq(3)
@@ -231,7 +236,7 @@ SKEEM
       (if (< x y) x y)))
 SKEEM
         subject.run(source)
-        procedure = subject.fetch('min').expression
+        procedure = subject.fetch('min')
         expect(procedure.arity).to eq(2)
         result = subject.run('(min 1 2)')
         expect(result).to eq(1)
@@ -631,7 +636,7 @@ SKEEM
           expect(result.to_a).to eq(expectation)
         end
       end
-      
+
       it 'should implement the cddr procedure' do
         checks = [
           ["(cddr '(2 1))", []]
@@ -640,7 +645,7 @@ SKEEM
           result = subject.run(skeem_expr)
           expect(result.to_a).to eq(expectation)
         end
-      end      
+      end
 
       it 'should implement the symbol=? procedure' do
         checks = [
@@ -656,19 +661,27 @@ SKEEM
     end # context
 
     context 'More advanced tests' do
-      it 'should implement second-order functions' do
+      it 'should implement lambda that calls second-order functions' do
         source = <<-SKEEM
+  (define twice
+    (lambda (x)
+      (* 2 x)))
   (define compose
     (lambda (f g)
       (lambda (x)
         (f (g x)))))
-  ((compose list square) 5)
+  (define repeat
+    (lambda (f)
+      (compose f f)))
+  ((repeat twice) 5)
 SKEEM
         result = subject.run(source)
-        expect(result.last.car).to eq(25)
+        expect(result.last).to eq(20)
       end
 
-      it 'should implement lambda that calls second-order functions' do
+#=begin
+      it 'under construction' do
+        # Fails
         source = <<-SKEEM
   (define twice
     (lambda (x)
@@ -680,11 +693,12 @@ SKEEM
   (define repeat
     (lambda (f)
       (compose f f)))
-  ((repeat twice) 5)
+  ((repeat (repeat twice)) 5)
 SKEEM
         result = subject.run(source)
-        expect(result.last).to eq(20)
+        expect(result.last).to eq(80)
       end
+#=end
     end # context
   end # describe
 end # module