skeem 0.0.15 → 0.0.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 17793fa7c6e636874b0d7fe8515d745b7ff664af
-  data.tar.gz: f24f83ad056e1af1ecac866e2daa649c94e544e6
+  metadata.gz: 8b34c77d5c2d4f0893f69e79e8973b4c6eca3481
+  data.tar.gz: f10a360e77925612bd6c95bb5e160417ba538983
 SHA512:
-  metadata.gz: 64d9feba80f8ac945161c326a8783cdd34babf4f46bbec94020192ad7643a408be059c72e922bf452387dff253708d2b855d7adbac93b9bb9fff0cf4f354bbce
-  data.tar.gz: 00f745fc5abeaa2f1f6d83007b21bc0cb7a4fbc3974d79f71be89c19324857a543339328d406a04ca5dd130e36c789c163e3b982c3be87b879b1978fbb277492
+  metadata.gz: da4f16148a354cb6ee8553d46e204ed97e27a88a117727a1c6a18f8441b5ed08a93fe56db11ade0fc903e934b60002315a98a70ef9b1a83d5015f7246f27ab4a
+  data.tar.gz: c75610b85fa5fa4a56c66832e19e193b401118dce728c5dacd755f5d570d3898939a11c2aa46ba83b9d1a6cde23d1a9e865657957dccc565e90c02c8806499aa

data/CHANGELOG.md

@@ -1,3 +1,18 @@
+## [0.0.16] - 2018-10-06
+- Added built-in procedures `odd?`, `even?`, `square`, and `floor-remainder` (`modulo`).
+- Supports procedures without argument.
+- Implements second syntax form for variable definition. 
+- Fixed nasty bug when same variable name used in nested procedure calls.
+
+### Added
+- Method `Environment#depth to count the nesting levels
+- File `primitive_builder.rb` implementation of: `odd?`, `even?`, `square`, `floor-remainder`, `modulo` procedures.
+- File `grammar.rb` rule for second syntax form for variable definition.
+- File `grammar.rb` rule for calling procedures without argument.
+
+### Fixed
+- Method `SkmDefinition#evaluate` Infinite recursion when a variable, say x, referred to a variable with same name in outer scope.
+
 ## [0.0.15] - 2018-09-30
 Recursive functions are now supported.  
 Interpreter pre-loads a Scheme file with standard procedures (zero?, positive?, negative?, abs)

data/lib/skeem/environment.rb

@@ -47,5 +47,19 @@ module Skeem
 
       my_result
     end
+    
+    # The number of outer parents the current environment has. 
+    # @return [Integer] The nesting levels
+    def depth
+      count = 0
+      
+      curr_env = self
+      while curr_env.outer
+        count += 1
+        curr_env = curr_env.outer
+      end
+      
+      count
+    end
   end # class
 end # module

data/lib/skeem/grammar.rb

@@ -27,6 +27,7 @@ module Skeem
     rule 'cmd_or_def' => 'definition'
     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('expression' =>  'IDENTIFIER').as 'variable_reference'
     rule 'expression' =>  'literal'
     rule 'expression' =>  'procedure_call'
@@ -36,13 +37,15 @@ module Skeem
     rule 'self-evaluating' => 'BOOLEAN'
     rule 'self-evaluating' => 'number'
     rule 'self-evaluating' => 'STRING_LIT'
-    rule 'procedure_call' => 'LPAREN operator RPAREN'
+    rule('procedure_call' => 'LPAREN operator RPAREN').as 'proc_call_nullary'
     rule('procedure_call' => 'LPAREN operator operand_plus RPAREN').as 'proc_call_args'
     rule('operand_plus' => 'operand_plus operand').as 'multiple_operands'
     rule('operand_plus' => 'operand').as 'last_operand'
     rule 'operator' => 'expression'
     rule 'operand' => 'expression'
     rule('lambda_expression' => 'LPAREN LAMBDA formals body RPAREN').as 'lambda_expression'
+    rule 'def_formals' => 'identifier_star'
+    # rule('def_formals' => 'identifier_star period identifier').as 'dotted_formals'
     rule('formals' => 'LPAREN identifier_star RPAREN').as 'identifiers_as_formals'
     rule 'formals' => 'IDENTIFIER'
     rule 'formals' => 'LPAREN identifier_plus PERIOD IDENTIFIER RPAREN'

data/lib/skeem/primitive/primitive_builder.rb

@@ -12,6 +12,8 @@ module Skeem
         add_boolean_procedures(aRuntime)
         add_string_procedures(aRuntime)
         add_symbol_procedures(aRuntime)
+        add_output_procedures(aRuntime)
+        add_special_procedures(aRuntime)
       end
 
       private
@@ -21,6 +23,7 @@ module Skeem
         def_procedure(aRuntime, create_minus)
         def_procedure(aRuntime, create_multiply)
         def_procedure(aRuntime, create_divide)
+        def_procedure(aRuntime, create_modulo)
       end
 
       def add_comparison(aRuntime)
@@ -50,6 +53,14 @@ module Skeem
         def_procedure(aRuntime, create_symbol?)
       end
 
+      def add_output_procedures(aRuntime)
+        def_procedure(aRuntime, create_newline)
+      end
+
+      def add_special_procedures(aRuntime)
+         def_procedure(aRuntime, create_debug)
+      end
+
       def create_plus()
         plus_code = ->(runtime, arglist) do
           first_one = arglist.head.evaluate(runtime)
@@ -102,6 +113,20 @@ module Skeem
         ['/', divide_code]
       end
 
+
+      def create_modulo()
+        modulo_code = ->(runtime, arglist) do
+          operand_1 = arglist.head.evaluate(runtime)
+          operands = arglist.tail.to_eval_enum(runtime)
+          operand_2 = operands.first.evaluate(runtime)
+          raw_result = operand_1.value.modulo(operand_2.value)
+          to_skm(raw_result)
+        end
+
+        ['floor-remainder', modulo_code, 'modulo', modulo_code]
+      end
+
+
       def create_equal
         equal_code = ->(runtime, arglist) do
           first_one = arglist.head.evaluate(runtime)
@@ -232,9 +257,29 @@ module Skeem
         ['symbol?', pred_code]
       end
 
-      def def_procedure(aRuntime, aPair)
-        func = PrimitiveProcedure.new(aPair.first, aPair.last)
-        define(aRuntime, func.identifier, func)
+      def create_newline
+        nl_code = ->(runtime, arg) do
+          # @TODO: make output stream configurable
+          print "\n"
+        end
+
+        ['newline', nl_code]
+      end
+
+      def create_debug
+        debug_code = ->(runtime, arg) do
+          require 'debug'
+        end
+
+        ['debug', debug_code]
+      end
+
+
+      def def_procedure(aRuntime, pairs)
+        pairs.each_slice(2) do |(name, code)|
+          func = PrimitiveProcedure.new(name, code)
+          define(aRuntime, func.identifier, func)
+        end
       end
 
       def define(aRuntime, aKey, anEntry)

data/lib/skeem/runtime.rb

@@ -24,6 +24,21 @@ module Skeem
       environment.bindings.clear
       @environment = environment.outer
     end
+    
+    def depth()
+      return environment.depth
+    end
+    
+    # Make the outer enviromnent thecurrent one inside the provided block
+    def pop
+      env = environment
+      @environment = environment.outer
+      env
+    end
+    
+    def push(anEnvironment)
+      @environment = anEnvironment
+    end
 
     private
 

data/lib/skeem/s_expr_builder.rb

@@ -61,11 +61,23 @@ module Skeem
     def reduce_definition(_production, aRange, _tokens, theChildren)
       SkmDefinition.new(aRange, theChildren[2], theChildren[3])
     end
+    
+    # rule('definition' => 'LPAREN DEFINE LPAREN IDENTIFIER def_formals RPAREN body RPAREN').as 'alt_definition'
+    # Equivalent to: (define IDENTIFIER (lambda (formals) body))
+    def reduce_alt_definition(_production, aRange, _tokens, theChildren)
+      lmbd = SkmLambda.new(aRange, theChildren[4], theChildren[6])
+      SkmDefinition.new(aRange, theChildren[3], lmbd)
+    end
 
     # rule('expression' =>  'IDENTIFIER').as 'variable_reference'
     def reduce_variable_reference(_production, aRange, _tokens, theChildren)
       SkmVariableReference.new(aRange, theChildren[0])
     end
+    
+    # rule('procedure_call' => 'LPAREN operator RPAREN').as 'proc_call_nullary'
+    def reduce_proc_call_nullary(_production, aRange, _tokens, theChildren)
+      ProcedureCall.new(aRange, theChildren[1], [])
+    end
 
     # rule('proc_call_args' => 'LPAREN operator operand_plus RPAREN')
     def reduce_proc_call_args(_production, aRange, _tokens, theChildren)
@@ -83,10 +95,18 @@ module Skeem
     end
     
     # rule('lambda_expression' => 'LPAREN LAMBDA formals body RPAREN').as 'lambda_expression'
-    def reduce_lambda_expression(_production, _range, _tokens, theChildren)
-      lmbd = SkmLambda.new(_range, theChildren[2], theChildren[3])
+    def reduce_lambda_expression(_production, aRange, _tokens, theChildren)
+      lmbd = SkmLambda.new(aRange, theChildren[2], theChildren[3])
+      # $stderr.puts lmbd.inspect
+      lmbd
     end
     
+    # rule('def_formals' => 'identifier_star period identifier').as 'dotted_formals'
+    def reduce_last_operand(_production, _range, _tokens, theChildren)
+      [theChildren.last]
+    end    
+    
+    
     # rule('formals' => 'LPAREN identifier_star RPAREN').as 'identifiers_as_formals'
     def reduce_identifiers_as_formals(_production, _range, _tokens, theChildren)
       theChildren[1]

data/lib/skeem/s_expr_nodes.rb

@@ -200,6 +200,7 @@ module Skeem
     # Construct an Enumerator that will return iteratively the result
     # of 'evaluate' method of each members of self.
     def to_eval_enum(aRuntime)
+=begin
       elements = self.members
 
       new_enum = Enumerator.new do |result|
@@ -208,6 +209,8 @@ module Skeem
       end
 
       new_enum
+=end
+      members.map { |elem| elem.evaluate(aRuntime) }
     end
 
     # Part of the 'visitee' role in Visitor design pattern.
@@ -245,9 +248,29 @@ module Skeem
 
     def evaluate(aRuntime)
       var_key = variable.evaluate(aRuntime)
-      aRuntime.define(var_key, self)
-      expression.evaluate(aRuntime) if expression.kind_of?(SkmLambda)
-      self
+      aRuntime.define(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
+            result = expression.evaluate(aRuntime)
+           else
+            # INFINITE LOOP DANGER: definition of 'x' is 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
+
+      result
     end
 
     # call method should only invoked when the expression is a SkmLambda
@@ -325,10 +348,10 @@ module Skeem
         raise err, err_msg
       end
       procedure = aRuntime.environment.fetch(var_key.value)
-      # puts "## CALL(#{var_key.value}) ###################"
-      # puts operands.inspect
+      # $stderr.puts "## CALL(#{var_key.value}) ###################"
+      # $stderr.puts operands.inspect
       result = procedure.call(aRuntime, self)
-      # puts "## RETURN #{result.inspect}"
+      # $stderr.puts "## RETURN #{result.inspect}"
       result
     end
 
@@ -394,7 +417,7 @@ module Skeem
       aRuntime.nest
       bind_locals(aRuntime, aProcedureCall)
       # TODO remove next line
-      # puts aRuntime.environment.inspect
+      # $stderr.puts aRuntime.environment.inspect
       result = evaluate_defs(aRuntime)
       result = evaluate_sequence(aRuntime)
       aRuntime.unnest
@@ -418,12 +441,12 @@ module Skeem
         if arg.nil?
           raise StandardError, "Unbound variable: '#{arg_name.value}'"
         end
-        
+
         # IMPORTANT: execute procedure call in argument list now
         arg = arg.evaluate(aRuntime) if arg.kind_of?(ProcedureCall)
         a_def = SkmDefinition.new(position, arg_name, arg)
         a_def.evaluate(aRuntime)
-        # puts "LOCAL #{a_def.inspect}"
+        # $stderr.puts "LOCAL #{a_def.inspect}"
       end
     end
 

data/lib/skeem/standard/base.skm

@@ -1,25 +1,41 @@
 ; Standard R7RS procedures from section 6.2.6
-(define zero? 
+(define zero?
   (lambda (z)
     (if (= z 0)
       #t
       #f)))
 
 ; Return true if x greater or equal to zero; false otherwise
-(define positive? 
+(define positive?
   (lambda (x)
     (if (>= x 0)
       #t
       #f)))
 
-(define negative? 
+(define negative?
   (lambda (x)
     (if (< x 0)
       #t
       #f)))
-      
-(define abs 
+
+(define odd?
+  (lambda (n)
+    (if (= (modulo n 2) 1)
+      #t
+      #f)))
+
+(define even?
+  (lambda (n)
+    (if (= (modulo n 2) 0)
+      #t
+      #f)))
+
+(define abs
   (lambda (x)
-    (if (>= x 0)
+    (if (positive? x)
       x
-      (- x))))
+      (- x))))
+
+(define square
+  (lambda (z)
+    (* z z)))

data/lib/skeem/version.rb

@@ -1,3 +1,3 @@
 module Skeem
-  VERSION = '0.0.15'.freeze
+  VERSION = '0.0.16'.freeze
 end

data/spec/skeem/environment_spec.rb

@@ -3,14 +3,26 @@ require_relative '../../lib/skeem/environment' # Load the class under test
 
 module Skeem
   describe Environment do
+    let(:sample_env) { Environment.new }
     context 'Initialization:' do
-      it 'should be initialized with opional argument' do
+      it 'could be initialized without argument' do
         expect { Environment.new() }.not_to raise_error
       end
+      
+      it 'could be initialized with optional argument' do
+        expect { Environment.new(sample_env) }.not_to raise_error
+      end
 
       it 'should have no default bindings' do
         expect(subject).to be_empty
       end
+      
+      it 'should have depth of zero or one' do
+        expect(subject.depth).to be_zero
+        
+        instance = Environment.new(sample_env)
+        expect(instance.depth).to eq(1)
+      end
     end # context
 
     context 'Provided services:' do

data/spec/skeem/interpreter_spec.rb

@@ -1,3 +1,4 @@
+require 'stringio'
 require_relative '../spec_helper' # Use the RSpec framework
 require_relative '../../lib/skeem/interpreter' # Load the class under test
 
@@ -128,8 +129,9 @@ SKEEM
       it 'should implement the lambda function with one arg' do
         source = <<-SKEEM
   ; Simplified 'abs' function implementation
-  (define abs (lambda(x)
-    (if (< x 0) (- x) x)))
+  (define abs 
+    (lambda (x)
+      (if (< x 0) (- x) x)))
 SKEEM
         subject.run(source)
         result = subject.run('(abs -3)')
@@ -143,8 +145,9 @@ SKEEM
       it 'should implement the lambda function with two args' do
         source = <<-SKEEM
   ; Simplified 'min' function implementation
-  (define min (lambda(x y)
-    (if (< x y) x y)))
+  (define min 
+    (lambda (x y)
+      (if (< x y) x y)))
 SKEEM
         subject.run(source)
         result = subject.run('(min 1 2)')
@@ -159,12 +162,25 @@ SKEEM
         source = <<-SKEEM
   ; Example from R7RS section 4.1.5
   (define fact (lambda (n) 
-    (if (<= n 1) 1 (* n (fact (- n 1))))))
+    (if (<= n 1) 
+      1 
+      (* n (fact (- n 1))))))
   (fact 10)
 SKEEM
         result = subject.run(source)
         expect(result.value).to eq(3628800)    
       end
+      
+    it 'should implement the compact define + lambda syntax' do
+        source = <<-SKEEM
+  ; Alternative syntax to: (define f (lambda x (+ x 42)))
+  (define (f x)
+    (+ x 42))
+  (f 23)
+SKEEM
+        result = subject.run(source)
+        expect(result.value).to eq(65)      
+    end
     end # context
 
     context 'Built-in primitive procedures' do
@@ -218,6 +234,20 @@ SKEEM
         expect(result).to be_kind_of(SkmInteger)
         expect(result.value).to eq(210)
       end
+      
+      it 'should implement the floor-remainder (modulo) procedure' do
+        checks = [
+          ['(modulo 16 4)', 0],
+          ['(modulo 5 2)', 1],
+          ['(modulo -45.0 7)', 4.0],
+          ['(modulo 10.0 -3.0)', -2.0],
+          ['(modulo -17 -9)', -8]
+        ]
+        checks.each do |(skeem_expr, expectation)|
+          result = subject.run(skeem_expr)
+          expect(result.value).to eq(expectation)
+        end
+      end
 
       it 'should implement the equality operator' do
         checks = [
@@ -376,6 +406,14 @@ SKEEM
           expect(result.value).to eq(expectation)
         end
       end
+      
+      it 'should implement the newline procedure' do
+        default_stdout = $stdout
+        $stdout = StringIO.new()
+        subject.run('(newline) (newline) (newline)')
+        expect($stdout.string).to match(/\n\n\n$/)
+        $stdout = default_stdout
+      end      
     end # context
     
     context 'Built-in standard procedures' do
@@ -439,6 +477,32 @@ SKEEM
         end
       end
 
+      it 'should implement the even? predicate' do      
+        checks = [
+          ['(even? 0)', true],
+          ['(even? 1)', false],       
+          ['(even? 2.0)', true],
+          ['(even? -120762398465)', false]
+        ]
+        checks.each do |(skeem_expr, expectation)|
+          result = subject.run(skeem_expr)
+          expect(result.value).to eq(expectation)
+        end
+      end
+
+      it 'should implement the odd? predicate' do      
+        checks = [
+          ['(odd? 0)', false],
+          ['(odd? 1)', true],       
+          ['(odd? 2.0)', false],
+          ['(odd? -120762398465)', true]
+        ]
+        checks.each do |(skeem_expr, expectation)|
+          result = subject.run(skeem_expr)
+          expect(result.value).to eq(expectation)
+        end
+      end       
+
       it 'should implement the abs function' do      
         checks = [
           ['(abs 3.1)', 3.1],
@@ -452,7 +516,19 @@ SKEEM
           result = subject.run(skeem_expr)
           expect(result.value).to eq(expectation)
         end
-      end       
+      end
+
+      it 'should implement the square function' do      
+        checks = [
+          ['(square 42)', 1764],
+          ['(square 2.0)', 4.0],       
+          ['(square -7)', 49]
+        ]
+        checks.each do |(skeem_expr, expectation)|
+          result = subject.run(skeem_expr)
+          expect(result.value).to eq(expectation)
+        end
+      end      
     end # context
   end # describe
 end # module

data/spec/skeem/runtime_spec.rb

@@ -32,17 +32,24 @@ module Skeem
       end
 
       it 'should add nested environment' do
+        expect(subject.depth).to be_zero
         env_before = subject.environment
         subject.nest
+        
         expect(subject.environment).not_to eq(env_before)
         expect(subject.environment.outer).to eq(env_before)
+        expect(subject.depth).to eq(1)
       end
 
       it 'should remove nested environment' do
+        expect(subject.depth).to be_zero
         subject.nest
         outer_before = subject.environment.outer
+        expect(subject.depth).to eq(1)
+        
         subject.unnest
         expect(subject.environment).to eq(outer_before)
+        expect(subject.depth).to be_zero
       end
     end # context
   end # describe

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: skeem
 version: !ruby/object:Gem::Version
-  version: 0.0.15
+  version: 0.0.16
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-09-30 00:00:00.000000000 Z
+date: 2018-10-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley