skeem 0.2.02 → 0.2.03

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ff26a0c0a06cb583052e17627fd7c620e26dc5c595613f1f6d5716a368c154b7
-  data.tar.gz: e7697be919dc2624c449ff001524d426ff914b2e09f8bc69f581599bd3961148
+  metadata.gz: 6d5dc31ad0db5984772c42897c9ce30f51b5d97b44e7c1b9e65a277f4294c767
+  data.tar.gz: cdb6ad6e66f703a65327fee0523be67a898215d2efa0e91371ec5b75b5262daa
 SHA512:
-  metadata.gz: 3a2ec84eec62e1bd007b480f89a843af69c023259dcfd37ae5808c8f7266f904ac0a6ab6ee8eb4f1877d3fbe16735c39c281c18ca16ee27c09307ae48f677287
-  data.tar.gz: e58e2a58401d9b8d6c17c9394029a4e2438917682e767e0541262c98ff4c0011dd8fd6b2fe998c019c96c7ce0a6007d2697d5987271858fba7c80d053242ba41
+  metadata.gz: ca03f6c15d90bbebae93cea809aaadd0dae35099bdcf6f7562182963e4c86c703d82a1955b3dde8ccd31369f85072a5e7a38cecaf8b8f4494775f3cf28c71611
+  data.tar.gz: 8167282d129ecf2e18563b5d6cceb1de387dab5ed4f8e63fc56655f33fc593fc79eeb8a650c72e88520d790b69d967e369e03552b261ce28052c709072867bbe

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [0.2.03] - 2019-04-26
+### Changed
+- File `README.md` added new example with procedures holding each their local states.
+
+### Fixed
+- The nesting of a lambda expression nested in a let construct caused an aliasing of the bindings.
+
 ## [0.2.02] - 2019-04-20
 ### Added
 - Skeem now supports 'let*' local binding construct
@@ -23,7 +30,7 @@
 
 ### Changed
 - File `.travis.yml` Added newer Ruby versions and more environments in "Allowed failures" because of Bundler issue.
-- File `README.md` udpated to reflect currently implemented features.
+- File `README.md` updated to reflect currently implemented features.
 - Class `SkmUndefined` uses now the Singleton pattern.
 
 ### Fixed

data/README.md

@@ -108,6 +108,37 @@ Here are a few pointers for the Scheme programming language:
   result = schemer.run(scheme_code)
   puts result.value # => 9332621544394415268169923885626670049071596826438162146859296389521759999322991560894146397615651828625369792082722375825118521091686400000000000000000000000
 ```
+### Example 4 (Defining a procedure that holds its own environment)
+```ruby
+  require 'skeem'
+
+  schemer = Skeem::Interpreter.new
+  scheme_code = <<-SKEEM
+  (define make-counter
+    ;; create a procedure that will bind count and
+    ;; return a new procedure that will iself increment the
+    ;; variable and return its newest value
+    (lambda ()
+       (let ((count 0))
+          (lambda ()
+             (set! count (+ count 1))
+             count))))
+
+  (define c1 (make-counter))
+  (define c2 (make-counter))
+  (define c3 (make-counter))
+
+  ;; Notice how each procedure keeps track of its "own" counter.
+  (c1) ; => 1
+  (c2) ; => 1
+  (c1) ; => 2
+  (c3) ; => 1
+  (c1) ; => 3
+  SKEEM
+
+  result = schemer.run(scheme_code)
+  puts result.last.value # => 3
+```
 
 ## Currently implemented R7RS features
 ### Data type literals

data/lib/skeem/grammar.rb

@@ -19,8 +19,8 @@ module Skeem
     add_terminals('STRING_LIT', 'IDENTIFIER')
 
     # Keywords...
-    add_terminals('DEFINE', 'IF', 'LAMBDA', 'LET')
-    add_terminals('LET*')
+    add_terminals('BEGIN', 'DEFINE', 'IF', 'LAMBDA')
+    add_terminals('LET', 'LET*')
     add_terminals('QUOTE', 'QUASIQUOTE', 'SET!')
     add_terminals('UNQUOTE', 'UNQUOTE-SPLICING')
 
@@ -29,9 +29,11 @@ module Skeem
     rule('cmd_or_def_plus' => 'cmd_or_def').as 'last_cmd_def'
     rule 'cmd_or_def' => 'command'
     rule 'cmd_or_def' => 'definition'
+    # TODO: add BEGIN here p. 64 R7RS
     rule 'command' => 'expression'
     rule('definition' => 'LPAREN DEFINE IDENTIFIER expression RPAREN').as 'definition'
     rule('definition' => 'LPAREN DEFINE LPAREN IDENTIFIER def_formals RPAREN body RPAREN').as 'alt_definition'
+    rule('definition' => 'LPAREN BEGIN definition_star RPAREN').as 'definitions_within_begin'
     rule('expression' =>  'IDENTIFIER').as 'variable_reference'
     rule 'expression' =>  'literal'
     rule 'expression' =>  'procedure_call'
@@ -80,8 +82,8 @@ module Skeem
     rule('identifier_plus' => 'identifier_plus IDENTIFIER').as 'multiple_identifiers'
     rule('identifier_plus' => 'IDENTIFIER').as 'last_identifier'
     rule('body' => 'definition_star sequence').as 'body'
-    rule 'definition_star' => 'definition_star definition'
-    rule 'definition_star' => []
+    rule('definition_star' => 'definition_star definition').as 'definition_star'
+    rule('definition_star' => []).as 'no_definition_yet'
     rule('sequence' => 'command_star expression').as 'sequence'
     rule('command_star' => 'command_star command').as 'multiple_commands'
     rule('command_star' => []).as 'no_command_yet'
@@ -95,6 +97,7 @@ module Skeem
     rule('assignment' => 'LPAREN SET! IDENTIFIER expression RPAREN').as 'assignment'
     rule('derived_expression' => 'LPAREN LET LPAREN binding_spec_star RPAREN body RPAREN').as 'short_let_form'
     rule('derived_expression' => 'LPAREN LET* LPAREN binding_spec_star RPAREN body RPAREN').as 'let_star_form'
+    rule('derived_expression' => 'LPAREN BEGIN sequence RPAREN').as 'begin_expression'
     rule 'derived_expression' => 'quasiquotation'
     rule('quasiquotation' => 'LPAREN QUASIQUOTE qq_template RPAREN').as 'quasiquotation'
     rule('quasiquotation' => 'GRAVE_ACCENT qq_template').as 'quasiquotation_short'

data/lib/skeem/primitive/primitive_procedure.rb

@@ -116,9 +116,9 @@ module Skeem
             arguments << operands.take(arity.low).flatten
             count_delta = operands.size - arity.low
             arguments << SkmPair.create_from_a(operands.slice(-count_delta, count_delta))
-            #p operands.size
-            #p count_delta
-            #p arguments.inspect
+            # p operands.size
+            # p count_delta
+            # p arguments.inspect
             result = code.send(:call, aRuntime, *arguments.flatten)
           end
         else # Fixed arity...

data/lib/skeem/s_expr_builder.rb

@@ -72,6 +72,11 @@ module Skeem
       # $stderr.puts lmbd.inspect
       SkmBinding.new(theChildren[3], lmbd)
     end
+    
+    # rule('definition' => 'LPAREN BEGIN definition_star RPAREN').as 'definitions_within_begin'
+    def reduce_definitions_within_begin(_production, aRange, _tokens, theChildren)
+      SkmSequencingBlock.new(SkmPair.create_from_a(theChildren[2]))     
+    end
 
     # rule('expression' =>  'IDENTIFIER').as 'variable_reference'
     def reduce_variable_reference(_production, aRange, _tokens, theChildren)
@@ -226,6 +231,17 @@ module Skeem
       definitions = theChildren[0].nil? ? [] : theChildren[0]
       { defs: definitions, sequence: theChildren[1] }
     end
+    
+    # rule('definition_star' => 'definition_star definition').as 'definition_star'
+    def reduce_definition_star(_production, _range, _tokens, theChildren)
+      theChildren[0] << theChildren[1]
+    end
+    
+    
+    # rule('definition_star' => []).as 'no_definition_yet' 
+    def reduce_no_definition_yet(_production, _range, _tokens, theChildren)
+      []
+    end    
 
     # rule('sequence' => 'command_star expression').as 'sequence'
     def reduce_sequence(_production, _range, _tokens, theChildren)
@@ -260,6 +276,11 @@ module Skeem
     # rule('derived_expression' => 'LPAREN LET* LPAREN binding_spec_star RPAREN body RPAREN').as 'let_star_form'
     def reduce_let_star_form(_production, aRange, _tokens, theChildren)
       SkmBindingBlock.new(:let_star, theChildren[3], theChildren[5])
+    end
+
+    # rule('derived_expression' => 'LPAREN BEGIN sequence RPAREN').as 'begin_expression'
+    def reduce_begin_expression(_production, aRange, _tokens, theChildren)
+      SkmSequencingBlock.new(theChildren[2])
     end    
 
     # rule('quasiquotation' => 'LPAREN QUASIQUOTE qq_template RPAREN').as 'quasiquotation'

data/lib/skeem/s_expr_nodes.rb

@@ -71,10 +71,10 @@ module Skeem
         # $stderr.puts "Parent environment #{aRuntime.environment.parent.object_id.to_s(16)}, "
         # $stderr.puts aRuntime.environment.inspect
       end
-      #$stderr.puts '  operator: ' + operator.inspect
-      #$stderr.puts '  original operands: ' + operands.inspect
+      # $stderr.puts '  operator: ' + operator.inspect
+      # $stderr.puts '  original operands: ' + operands.inspect
       actuals = transform_operands(aRuntime)
-      #$stderr.puts '  transformed operands: ' + actuals.inspect
+      # $stderr.puts '  transformed operands: ' + actuals.inspect
       outcome, result = determine_callee(aRuntime)
       if outcome == :callee
         callee = result
@@ -464,6 +464,14 @@ require_relative 'skm_procedure_exec'
       
       result
     end
+    
+    def doppelganger(aRuntime)
+      twin = self.dup
+      twin.set_cond_environment(aRuntime.environment.dup)
+      result = twin
+      
+      result
+    end    
 
     def set_cond_environment(theFrame)
       # $stderr.puts "Lambda #{object_id.to_s(16)}, env [#{environment.object_id.to_s(16)}]"

data/lib/skeem/skm_frame.rb

@@ -16,7 +16,14 @@ module Skeem
       @bindings = {}
       @parent = parentFrame
     end
-    
+
+    def initialize_copy(original)
+      @bindings = {}
+      original.bindings.each_pair do |var, val|
+        add_binding(var.dup, val.dup)
+      end
+    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
@@ -29,7 +36,7 @@ module Skeem
     # @param anIdentifier [String, SkmIdentifier] The variable name.
     # @param anExpression [SkmElement] The Skeem expression to bind
     def update_binding(anIdentifier, anExpression)
-      variable = valid_identifier(anIdentifier) 
+      variable = valid_identifier(anIdentifier)
       if bindings.include?(variable)
         bind(variable, anExpression)
       elsif parent
@@ -52,7 +59,7 @@ module Skeem
 
     # Tell  the value of an existing variable.
     # @param anIdentifier [String, SkmIdentifier] The variable name.
-    # @return [Boolean]    
+    # @return [Boolean]
     def include?(anIdentifier)
       variable = valid_identifier(anIdentifier)
       my_result = bindings.include?(variable)
@@ -110,9 +117,9 @@ module Skeem
 
       result
     end
-    
+
     private
-    
+
     def valid_identifier(anIdentifier)
       case anIdentifier
         when String
@@ -125,13 +132,13 @@ module Skeem
           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)    
+      anExpression.bound!(self)
     end
-    
+
   end # class
 end # module

data/lib/skeem/skm_unary_expression.rb

@@ -110,20 +110,20 @@ module Skeem
       variable.value
     end
   end # class
-  
+
   # Used to represent local binding constructs (let, let*, letrec, letrec*)
   class SkmBindingBlock < SkmUnaryExpression
     alias body child
-    
+
     attr_reader :kind
     attr_reader :bindings
-    
+
     def initialize(theKind, theBindings, aBody)
       @kind = theKind
       @bindings = theBindings
       super(nil, aBody)
     end
-    
+
     def evaluate(aRuntime)
       aRuntime.push(SkmFrame.new(aRuntime.environment))
       if kind == :let
@@ -137,14 +137,59 @@ module Skeem
         bindings.each do |bnd|
           val = bnd.value.evaluate(aRuntime)
           aRuntime.add_binding(bnd.variable.evaluate(aRuntime), val)
-        end        
+        end
+      end
+
+      unless body[:defs].empty?
+        body[:defs].each do |dfn|
+          dfn.evaluate(aRuntime)
+        end
       end
-      
-      result = body[:sequence].evaluate(aRuntime)
+
+      # $stderr.puts "Environment SkmBindingBlock#evaluate:" + aRuntime.environment.inspect
+      raw_result = body[:sequence].evaluate(aRuntime)
+      result = raw_result.kind_of?(SkmPair) ? raw_result.last : raw_result
+      result = result.doppelganger(aRuntime) if result.kind_of?(SkmLambda)
+
       aRuntime.pop
-      result.kind_of?(SkmPair) ? result.last : result
+      # $stderr.puts "Result SkmBindingBlock#evaluate: " + result.inspect
+      result
     end
-    
+
   end # class
-  
+
+  # Sequencing construct
+  class SkmSequencingBlock < SkmUnaryExpression
+    alias sequence child
+
+    def initialize(aSequence)
+      super(nil, aSequence)
+    end
+
+    def evaluate(aRuntime)
+      result = nil
+      if sequence
+        sequence.kind_of?(SkmPair)
+          sequence.to_a.each do |cmd|
+            begin
+              if cmd.kind_of?(SkmLambda)
+                result = cmd.dup_cond(aRuntime)
+              else
+                result = cmd.evaluate(aRuntime)
+              end
+            rescue NoMethodError => exc
+              $stderr.puts self.inspect
+              $stderr.puts sequence.inspect
+              $stderr.puts cmd.inspect
+              raise exc
+            end
+          end
+        elsif
+          result = sequence.evaluate(aRuntime)
+        end
+
+      result
+    end
+  end # class
+
 end # module

data/lib/skeem/version.rb

@@ -1,3 +1,3 @@
 module Skeem
-  VERSION = '0.2.02'.freeze
+  VERSION = '0.2.03'.freeze
 end

data/spec/skeem/interpreter_spec.rb

@@ -330,7 +330,7 @@ SKEEM
         expect(result.last).to eq(66)
       end
 
-     it 'should support the nesting of local bindings' do
+      it 'should support the nesting of local bindings' do
         source = <<-SKEEM
   (let ((x 2) (y 3))
   (let ((x 7)
@@ -341,6 +341,29 @@ SKEEM
         expect(result).to eq(35)
       end
 
+      it 'should support the nesting of a lambda in a let expression' do
+        source =<<-SKEEM
+  (define make-counter
+    (lambda ()
+       (let ((count 0))
+          (lambda ()
+             (set! count (+ count 1))
+             count))))
+
+  (define c1 (make-counter))
+  (define c2 (make-counter))
+  (c1)
+  (c2)
+  (c1)
+  (c2)
+  (c1)
+SKEEM
+        result = subject.run(source)
+        expect(result.last).to eq(3)
+      end
+
+
+
       it 'should implement let* expression' do
         source = <<-SKEEM
   (let ((x 2) (y 3))
@@ -353,6 +376,29 @@ SKEEM
       end
     end # context
 
+    context 'Sequencing constructs:' do
+      it 'should implement begin as a sequence of expressions' do
+        source = <<-SKEEM
+  (define x 0)
+  (and (= x 0)
+    (begin (set! x 5)
+      (+ x 1))) ; => 6
+SKEEM
+        result = subject.run(source)
+        expect(result.last).to eq(6)
+      end
+
+      it 'should implement begin as a sequence of expressions' do
+        source = <<-SKEEM
+  (let ()
+    (begin (define x 3) (define y 4))
+    (+ x y))  ; => 7
+SKEEM
+        result = subject.run(source)
+        expect(result).to eq(7)
+      end
+    end # context
+
     context 'Quasiquotation:' do
       it 'should implement the quasiquotation of constant literals' do
          checks = [

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: skeem
 version: !ruby/object:Gem::Version
-  version: 0.2.02
+  version: 0.2.03
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-04-20 00:00:00.000000000 Z
+date: 2019-04-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley