skeem 0.2.04 → 0.2.05

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8efda1e2bcaf2e4d07ca4bc52f3708c0e217b27c191d6ed0a42d3b7125e26de5
-  data.tar.gz: '0359bae57e376f724f17b0e10bcc819f6fe8ee1f2478d2b330111c16546ab8ec'
+  metadata.gz: f8c3a61e9162fe0df33e51f373614d56cac6e5bc9c4743a101b8805bad158843
+  data.tar.gz: 52feb4bc5edf9e9cf64089ef0e3fbb6cff2d917d964ecdf4d1e00d1d1409caed
 SHA512:
-  metadata.gz: 48f64eea51bbbe3e701214101ad7bf114cf45ef4281db722de2b2786d0e932793cf6945bd2cfbb6afc8ea320264ca7eb920fc79d0f7a81ac49efd1cd9af863c1
-  data.tar.gz: d4ae84b2ebf2d3a20efcbb950d11ea1fc2b31b06a62d33c5fd375df6ff726a0a0b51f2a693f8cb3d0a47864de59ed79f2fbafe2cad9e99092ce25f0784271944
+  metadata.gz: 1e99664327739a23130244b2cff9b81e9ad9be83773efc057cdb636f8642a3a1492a8de5ed0133857582c036228f27c22c5bf3e17949bd577f162b679c7aa090
+  data.tar.gz: 9014bdfed6b945a604ab55f940de00c9288773a0dd9a192825b5cd83e99d79c6434252e96289abbfe10b7f742ffa117034f767685c929b5dbefcb2d27e7c36d3

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [0.2.05] - 2019-05-26
+- Passing more standard Scheme tests, `append` procedure implemented.
+
+### Added
+- File `primitive_builder.rb`: Added implementation for standard procedure `append`.
+- Class `LambdaRep`: represents a parse tree of a lambda expression.
+
+### Changed
+- File `grammar.rb`: Changed a grammar rule for (begin ...) expression because R7RS was too restrictive compared to main implementations.
+- Class `SkmBuilder` several method updates (e.g. `reduce_alt_definition`)
+
+### Removed
+- Class `Environment` superseded by class `SkmFrame`
+
 ## [0.2.04] - 2019-04-29
 - Support for local definitions [initial]
 

data/README.md

@@ -221,7 +221,7 @@ This section lists the implemented standard procedures
 * Integer-level: `even?`, `odd?`
 
 #### List procedures
-* `list?`, `null?`, `pair?`, `car`, `cdr`, `caar`, `cadr`, `cdar`, `cddr`,  `cons`,  `length`, `list`, `list->vector`, `set-car!`, `set-cdr!`
+* `list?`, `null?`, `pair?`, `append`, `car`, `cdr`, `caar`, `cadr`, `cdar`, `cddr`,  `cons`,  `length`, `list`, `list->vector`, `set-car!`, `set-cdr!`
 
 #### String procedures
 * `string?`, `string=?`,  `string-append`, `string-length`, `string->symbol`
@@ -255,7 +255,7 @@ Here are a few other ones:
 
 - [rubic gem](https://rubygems.org/gems/rubic). The last commit for the [project](https://github.com/notozeki/rubic) is June 2015.
 
-- [RLisp](https://github.com/davydovanton/rlisp) ...Simple scheme interpreter written on ruby
+- [RLisp](https://github.com/davydovanton/rlisp) ...Simple scheme interpreter written in ruby
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/famished-tiger/Skeem.

data/lib/skeem/grammar.rb

@@ -39,7 +39,7 @@ module Skeem
     rule 'expression' =>  'procedure_call'
     rule 'expression' =>  'lambda_expression'
     rule 'expression' =>  'conditional'
-    rule 'expression' =>  'assignment'    
+    rule 'expression' =>  'assignment'
     rule 'expression' =>  'derived_expression'
     rule 'literal' => 'quotation'
     rule 'literal' => 'self-evaluating'
@@ -97,7 +97,10 @@ 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'
+
+    # As the R7RS grammar is too restrictive, 
+    # the next rule was made more general than its standard counterpart
+    rule('derived_expression' => 'LPAREN BEGIN body 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_builder.rb

@@ -104,6 +104,7 @@ module Skeem
         create_cdr(aRuntime)
         create_length(aRuntime)
         create_list2vector(aRuntime)
+        create_append(aRuntime)
         create_setcar(aRuntime)
         create_setcdr(aRuntime)
       end
@@ -485,6 +486,44 @@ module Skeem
 
         define_primitive_proc(aRuntime, 'list->vector', unary, primitive)
       end
+      
+      def create_append(aRuntime)
+        primitive = ->(runtime, arglist) do
+          if arglist.empty?
+            result = SkmEmptyList.instance
+          elsif arglist.size == 1
+            result = arglist[0]
+          else
+            parts = evaluate_arguments(arglist, aRuntime)
+            but_last = parts.take(parts.length - 1)
+            check_arguments(but_last, [SkmPair, SkmEmptyList], 'list', 'append')
+            result = parts.shift.klone  # First list is taken 
+            parts.each do |arg|
+              case arg
+                when SkmPair
+                  cloned = arg.klone
+                  if result.kind_of?(SkmEmptyList)
+                    result = cloned
+                  else
+                    if result.kind_of?(SkmEmptyList)
+                      result = SkmPair.new(arg, SkmEmptyList.instance)
+                    else
+                      result.append_list(cloned)
+                    end
+                  end
+                when SkmEmptyList
+                  # Do nothing
+                else
+                  result.append(arg)
+              end
+            end
+          end
+
+          result
+        end      
+      
+        define_primitive_proc(aRuntime, 'append', zero_or_more, primitive)
+      end
 
       def create_setcar(aRuntime)
         primitive = ->(runtime, pair_arg, obj_arg) do
@@ -682,6 +721,20 @@ module Skeem
           arglist.evaluate(aRuntime).to_a
         end
       end
+      
+      def check_arguments(arguments, requiredRubyClass, requiredSkmType, aProcName)
+        arguments.each do |argument|
+          if requiredRubyClass.kind_of?(Array)
+            unless requiredRubyClass.include?(argument.class)
+              type_error(argument, requiredSkmType, aProcName)
+            end
+          else
+            unless argument.kind_of?(requiredRubyClass)
+              type_error(argument, requiredSkmType, aProcName)
+            end
+          end
+        end
+      end 
 
       def check_argtype(argument, requiredRubyClass, requiredSkmType, aProcName)
         if requiredRubyClass.kind_of?(Array)

data/lib/skeem/s_expr_builder.rb

@@ -73,7 +73,7 @@ module Skeem
     # 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])
+      lmbd = SkmLambdaRep.new(aRange, theChildren[4], theChildren[6])
       # $stderr.puts lmbd.inspect
       SkmBinding.new(theChildren[3], lmbd)
     end
@@ -190,7 +190,7 @@ module Skeem
 
     # rule('lambda_expression' => 'LPAREN LAMBDA formals body RPAREN').as 'lambda_expression'
     def reduce_lambda_expression(_production, aRange, _tokens, theChildren)
-      lmbd = SkmLambda.new(aRange, theChildren[2], theChildren[3])
+      lmbd = SkmLambdaRep.new(aRange, theChildren[2], theChildren[3])
       # $stderr.puts lmbd.inspect
       lmbd
     end
@@ -251,6 +251,7 @@ module Skeem
     # rule('sequence' => 'command_star expression').as 'sequence'
     def reduce_sequence(_production, _range, _tokens, theChildren)
       SkmPair.create_from_a(theChildren[0] << theChildren[1])
+      
     end
 
     # rule('command_star' => 'command_star command').as 'multiple_commands'
@@ -283,9 +284,9 @@ module Skeem
       SkmBindingBlock.new(:let_star, theChildren[3], theChildren[5])
     end
 
-    # rule('derived_expression' => 'LPAREN BEGIN sequence RPAREN').as 'begin_expression'
+    # rule('derived_expression' => 'LPAREN BEGIN body RPAREN').as 'begin_expression'
     def reduce_begin_expression(_production, aRange, _tokens, theChildren)
-      SkmSequencingBlock.new(theChildren[2])
+      SkmSequencingBlock.new(theChildren[2]) 
     end    
 
     # rule('quasiquotation' => 'LPAREN QUASIQUOTE qq_template RPAREN').as 'quasiquotation'

data/lib/skeem/s_expr_nodes.rb

@@ -71,12 +71,12 @@ 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 '  operator: ' + (operands.kind_of?(SkmLambda) ? "lambda #{object_id.to_s(16)}" : operator.inspect)
       # $stderr.puts '  original operands: ' + operands.inspect
-      actuals = transform_operands(aRuntime)
-      # $stderr.puts '  transformed operands: ' + actuals.inspect
       outcome, result = determine_callee(aRuntime)
       if outcome == :callee
+        actuals = transform_operands(aRuntime)
+        # $stderr.puts '  transformed operands: ' + actuals.inspect
         callee = result
         # if callee.kind_of?(SkmLambda)
           # aRuntime.push(callee.environment)
@@ -125,6 +125,8 @@ module Skeem
           # callee = fetch_callee(aRuntime, result)
         when Primitive::PrimitiveProcedure
           callee = operator
+        when SkmLambdaRep
+          callee = operator.evaluate(aRuntime)
         when SkmLambda
           callee = operator
         else
@@ -301,10 +303,11 @@ module Skeem
   end # class
 
 
-
-require_relative 'skm_procedure_exec'
-
-  class SkmLambda < SkmMultiExpression
+  # Parse tree representation of a Lambda
+  # - Not bound to a frame (aka environment)
+  # - Knows the parse representation of its embedded definitions
+  # - Knows the parse representation of the body
+  class SkmLambdaRep < SkmMultiExpression
     include DatumDSL
 
     # @!attribute [r] formals
@@ -312,7 +315,6 @@ require_relative 'skm_procedure_exec'
     attr_reader :formals
     attr_reader :definitions
     attr_reader :sequence
-    attr_reader :environment
 
     def initialize(aPosition, theFormals, aBody)
       super(aPosition)
@@ -321,6 +323,158 @@ require_relative 'skm_procedure_exec'
       @sequence = aBody[:sequence]
     end
 
+    def evaluate(aRuntime)
+      SkmLambda.new(self, aRuntime)
+    end
+
+    def callable?
+      true
+    end
+
+    def call(aRuntime, theActuals)
+      set_cond_environment(aRuntime.environment) # Last chance for anonymous lambda
+      application = SkmProcedureExec.new(self)
+      application.run!(aRuntime, theActuals)
+    end
+
+    def arity
+      formals.arity
+    end
+
+    def required_arity
+      formals.required_arity
+    end
+
+    alias eqv? equal?
+    alias skm_equal? equal?
+
+    def bound!(aFrame)
+      set_cond_environment(aFrame)
+    end
+
+    def inspect
+      result = inspect_prefix + "@object_id=#{object_id.to_s(16)}, "
+      result << inspect_specific
+      result << inspect_suffix
+      result
+    end
+
+    def associations
+      [:formals, :definitions, :sequence]
+    end
+
+    def bind_locals(aRuntime, theActuals)
+      actuals =  theActuals
+      count_actuals = actuals.size
+
+      if (count_actuals < required_arity) ||
+        ((count_actuals > required_arity) && !formals.variadic?)
+        # $stderr.puts "Error"
+        # $stderr.puts self.inspect
+        raise StandardError, msg_arity_mismatch(theActuals)
+      end
+      return if count_actuals.zero? && !formals.variadic?
+      bind_required_locals(aRuntime, theActuals)
+      if formals.variadic?
+        variadic_part_raw = actuals.drop(required_arity)
+        variadic_part = variadic_part_raw.map do |actual|
+          case actual
+            when ProcedureCall
+              actual.evaluate(aRuntime)
+            when SkmQuotation
+              actual.evaluate(aRuntime)
+            else
+              to_datum(actual)
+          end
+        end
+        variadic_arg_name = formals.formals.last
+        args_coll = SkmPair.create_from_a(variadic_part)
+        a_def = SkmBinding.new(variadic_arg_name, args_coll)
+        a_def.evaluate(aRuntime)
+        aRuntime.add_binding(a_def.variable, a_def.value)
+        # $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
+    end
+
+    private
+
+    # Purpose: bind each formal from lambda to an actual value from the call
+    def bind_required_locals(aRuntime, theActuals)
+      max_index = required_arity - 1
+      actuals = theActuals
+      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 = SkmPair.create_from_a([])
+          else
+            raise StandardError, "Unbound variable: '#{arg_name.value}'"
+          end
+        end
+
+        # 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)
+        a_def = SkmBinding.new(arg_name, arg)
+        # $stderr.puts "Lambda #{object_id.to_s(16)}"
+        # $stderr.puts "LOCAL #{arg_name.value} #{arg.inspect}"
+        if arg.kind_of?(SkmVariableReference) && !formal_names.include?(arg.value)
+          aRuntime.add_binding(arg_name, a_def)
+        else
+          aRuntime.add_binding(a_def.variable, a_def.evaluate(aRuntime))
+        end
+        break if index >= max_index
+      end
+    end
+
+    def msg_arity_mismatch(actuals)
+      # *** ERROR: wrong number of arguments for #<closure morph> (required 2, got 1)
+      msg1 = "Wrong number of arguments for procedure "
+      count_actuals = actuals.size
+      msg2 = "(required #{required_arity}, got #{count_actuals})"
+      msg1 + msg2
+    end
+
+    def inspect_specific
+      result = ''
+      result << '@formals ' + formals.inspect + ', '
+      result << '@definitions ' + definitions.inspect + ', '
+      result << '@sequence ' + sequence.inspect + inspect_suffix
+
+      result
+    end
+  end # class
+
+
+
+
+require 'forwardable'
+require_relative 'skm_procedure_exec'
+
+  class SkmLambda < SkmMultiExpression
+    include DatumDSL
+    extend Forwardable
+
+    attr_reader :representation
+    attr_reader :environment    
+    
+    def_delegators(:@representation, :formals, :definitions, :sequence)
+
+    def initialize(aRepresentation, aRuntime)
+      @representation = aRepresentation
+      @environment = aRuntime.environment
+    end
+
     def evaluate(aRuntime)
       self
     end
@@ -429,7 +583,7 @@ require_relative 'skm_procedure_exec'
 
       result
     end
-    
+
     def dup_cond(aRuntime)
       if environment
         result = self
@@ -438,17 +592,17 @@ require_relative 'skm_procedure_exec'
         twin.set_cond_environment(aRuntime.environment)
         result = twin
       end
-      
+
       result
     end
-    
+
     def doppelganger(aRuntime)
       twin = self.dup
       twin.set_cond_environment(aRuntime.environment.dup)
       result = twin
-      
+
       result
-    end    
+    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_empty_list.rb

@@ -2,7 +2,7 @@ require 'singleton'
 require_relative 'skm_element'
 
 module Skeem
-  # From R7RS: The empty list is a special object of its own type. 
+  # 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
@@ -14,30 +14,38 @@ module Skeem
     def null?
       true
     end
-    
+
     def pair?
       false
     end
-    
+
     def length
       0
     end
-    
+
     def empty?
       true
     end
-    
+
     def verbatim?
       true
     end
-    
+
     def skm_equal?(other)
       equal?(other)
     end
-    
+
     def to_a
       []
-    end    
+    end
+
+    def klone
+      self
+    end
+    
+    def append_list(aList)
+      aList
+    end
 
     def evaluate(_runtime)
       self

data/lib/skeem/skm_pair.rb

@@ -14,6 +14,15 @@ module Skeem
       @cdr = tail
     end
 
+    def klone
+      if cdr.kind_of?(SkmPair)
+        new_cdr = cdr.klone
+      else
+        new_cdr = cdr
+      end
+      self.class.new(car, new_cdr)
+    end
+
     # Construct new instance with car and cdr respectively equal to
     # car.evaluate and cdr.evaluate
     def clone_evaluate(aRuntime)
@@ -82,6 +91,14 @@ module Skeem
       result
     end
 
+    def last_pair
+      if cdr.nil? || (cdr == SkmEmptyList.instance) || (!cdr.kind_of?(SkmPair))
+        self
+      else
+        cdr.last_pair
+      end
+    end
+
     def last
       self.to_a.last
     end
@@ -116,15 +133,23 @@ module Skeem
     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)
+      last_one = self.last_pair
+      if last_one.cdr.nil? || last_one.cdr.kind_of?(SkmEmptyList)
+        last_one.cdr = SkmPair.new(anElement, SkmEmptyList.instance)
       else
         raise StandardError, "Cannot append #{anElement.inspect}"
       end
     end
 
+    def append_list(aList)
+      last_one = self.last_pair
+      if last_one.cdr.nil? || last_one.cdr.kind_of?(SkmEmptyList)
+        last_one.cdr = aList
+      else
+        raise StandardError, "Cannot append list #{aList.inspect}"
+      end
+    end
+
     def evaluate(aRuntime)
       return SkmEmptyList.instance if empty?
       if car.kind_of?(SkmIdentifier) && car.is_var_name

data/lib/skeem/skm_procedure_exec.rb

@@ -19,9 +19,11 @@ module Skeem
       runtime.push(frame)
       definition.bind_locals(runtime, theActuals)
       evaluate_defs(aRuntime)
-      # definition.evaluate_defs(runtime)
       # $stderr.puts "Locals"
-      # $stderr.puts frame.bindings.keys.join(', ')      
+      # frame.bindings.each_pair do |key, elem|
+        # $stderr.print key.to_s + ' => '
+        # $stderr.puts  elem.kind_of?(SkmLambda) ? "  Lambda = #{elem.object_id.to_s(16)}" : elem.inspect
+      # end
       result = definition.evaluate_sequence(runtime)
       runtime.pop
       # $stderr.puts "Lambda result: #{result.object_id.to_s(16)}" if result.kind_of?(SkmLambda)
@@ -33,8 +35,8 @@ module Skeem
     
     def evaluate_defs(aRuntime)
       definition.definitions.each do |bndng|
+        val = bndng.value.evaluate(aRuntime)      
         var = bndng.variable.evaluate(aRuntime)
-        val = bndng.value.evaluate(aRuntime)
         frame.add_binding(var, val)
       end    
     end

data/lib/skeem/skm_unary_expression.rb

@@ -160,7 +160,7 @@ module Skeem
 
   # Sequencing construct
   class SkmSequencingBlock < SkmUnaryExpression
-    alias sequence child
+    alias sequence child # Can be a body
 
     def initialize(aSequence)
       super(nil, aSequence)
@@ -168,26 +168,73 @@ module Skeem
 
     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
+      return result if sequence.nil?
+
+      case sequence
+        when SkmPair
+          result = eval_pair(aRuntime)
+        when Hash
+          result = eval_body(aRuntime)
+        else
+          result = sequence.evaluate(aRuntime)
+      end
+
+      result
+    end
+
+    private
+
+    def eval_pair(aRuntime)
+      result = nil
+      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
+
+      result
+    end
+
+    def eval_body(aRuntime)
+      result = nil
+      aRuntime.push(SkmFrame.new(aRuntime.environment))
+
+      unless sequence[:defs].empty?
+        sequence[:defs].each do |dfn|
+          dfn.evaluate(aRuntime)
+        end
+      end
+
+      if sequence[:sequence].kind_of?(SkmPair)
+        sequence[: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[:sequence].inspect
+            $stderr.puts cmd.inspect
+            raise exc
           end
-        elsif
-          result = sequence.evaluate(aRuntime)
         end
+      elsif
+        result = sequence.evaluate(aRuntime)
+      end
 
+      aRuntime.pop
+      
       result
     end
   end # class

data/lib/skeem/version.rb

@@ -1,3 +1,3 @@
 module Skeem
-  VERSION = '0.2.04'.freeze
+  VERSION = '0.2.05'.freeze
 end

data/spec/skeem/interpreter_spec.rb

@@ -304,20 +304,21 @@ SKEEM
           result = subject.run(source)
           expect(result.last.last.value).to eq(4)
       end
-      
-      
+
       it 'should support the nested define construct' do
         source = <<-SKEEM
   (define (quadruple x)
     (define (double x) ; define a local procedure double
       (+ x x))
     (double (double x))) ; nested calls to the local procedure
- 
+
   (quadruple 5) ; => 20
 SKEEM
         result = subject.run(source)
-        expect(result.last.value).to eq(20)    
+        expect(result.last.value).to eq(20)
       end
+      
+      
     end # context
 
     context 'Binding constructs:' do
@@ -376,8 +377,6 @@ SKEEM
         expect(result.last).to eq(3)
       end
 
-
-
       it 'should implement let* expression' do
         source = <<-SKEEM
   (let ((x 2) (y 3))
@@ -411,6 +410,21 @@ SKEEM
         result = subject.run(source)
         expect(result).to eq(7)
       end
+      
+      it 'should support begin as lambda body' do
+        source = <<-SKEEM
+  (define kube (lambda (x)
+    (begin
+      (define z x)
+      (* z z z)
+    )
+  ))
+  (kube 3)
+  (kube 4)
+SKEEM
+        result = subject.run(source)
+        expect(result.last).to eq(64)
+      end      
     end # context
 
     context 'Quasiquotation:' do

data/spec/skeem/primitive/primitive_builder_spec.rb

@@ -452,7 +452,10 @@ SKEEM
             ['(list? #f)', false],
             ['(list? 1)', false],
             ['(list? "bar")', false],
+            ["(list? 'a)", false],
+            ["(list? '(a))", true],
             ["(list? '(1 2 3))", true],
+            ["(list? '(3 . 4))", false],
             ["(list? '())", true]
           ]
           checks.each do |(skeem_expr, expectation)|
@@ -563,6 +566,36 @@ SKEEM
           end
         end
 
+        def array2list_ids(arr)
+          arr.map { |elem| SkmIdentifier.create(elem) }
+        end
+
+        it 'should implement the append procedure' do
+          checks = [
+            ["(append '(a b c) '())", array2list_ids(['a', 'b', 'c'])],
+            ["(append '() '(a b c))", array2list_ids(['a', 'b', 'c'])],
+            ["(append '(x) '(y))", array2list_ids(['x', 'y'])],
+            ["(append '(a) '(b c d))", array2list_ids(['a', 'b', 'c', 'd'])],
+            ["(append '(a b) '(c d))", array2list_ids(['a', 'b', 'c', 'd'])],
+            ["(append '(a b) '(c) 'd)", array2list_ids(['a', 'b', 'c', 'd'])],
+            ["(append '(a (b)) '((c)))", [SkmIdentifier.create('a'),
+              SkmPair.create_from_a(array2list_ids(['b'])),
+              SkmPair.create_from_a(array2list_ids(['c']))]]
+          ]
+          checks.each do |(skeem_expr, expectation)|
+            result = subject.run(skeem_expr)
+            expect(result.to_a).to eq(expectation)
+          end
+        end
+
+        it 'should implement the procedure for an improper list' do
+          result = subject.run("(append '(a b) '(c . d))")
+          expect(result.car).to eq( SkmIdentifier.create('a'))
+          expect(result.cdr.car).to eq( SkmIdentifier.create('b'))
+          expect(result.cdr.cdr.car).to eq( SkmIdentifier.create('c'))
+          expect(result.cdr.cdr.cdr).to eq( SkmIdentifier.create('d'))
+        end
+
         it 'should implement the list->vector procedure' do
           checks = [
             ["(list->vector '())", []],

data/spec/skeem/s_expr_nodes_spec.rb

@@ -71,18 +71,18 @@ module Skeem
     end # context
   end # describe
 
-  describe SkmLambda do
+  describe SkmLambdaRep do
     let(:pos) { double('fake-position') }
     let(:s_formals) { double('fake-formals') }
     let(:s_defs) { double('fake-definitions') }
     let(:s_sequence) { double('fake-sequence') }
     let(:s_body) do { defs: s_defs, sequence: s_sequence } end
 
-    subject { SkmLambda.new(pos, s_formals, s_body) }
+    subject { SkmLambdaRep.new(pos, s_formals, s_body) }
 
     context 'Initialization:' do
       it 'should be initialized with a pos and 3 expressions' do
-        expect{ SkmLambda.new(pos, s_formals, s_body) }.not_to raise_error
+        expect{ SkmLambdaRep.new(pos, s_formals, s_body) }.not_to raise_error
       end
 
       it 'should know its formals' do
@@ -100,7 +100,7 @@ module Skeem
 
     context 'Provided services:' do
       it 'should return its text representation' do
-        txt1 = '<Skeem::SkmLambda: @formals #<Double "fake-formals">, '
+        txt1 = '<Skeem::SkmLambdaRep: @formals #<Double "fake-formals">, '
         txt2 = '@definitions #<Double "fake-definitions">, '
         txt3 = '@sequence #<Double "fake-sequence">>>'
         # Remove "unpredictable" part of actual text

data/spec/skeem/skm_pair_spec.rb

@@ -34,11 +34,37 @@ module Skeem
     end # context
 
     context 'Provided services:' do
-      let(:runtime) { Runtime.new(Environment.new) }
+      let(:runtime) { Runtime.new(SkmFrame.new) }
       let(:list_length_2) { SkmPair.new(integer(10), subject) }
       let(:quirk_element) { double('three') }
       let(:quirk_members) { [integer(10), quirk_element] }
 
+      it 'should clone itself' do
+        cloned = subject.klone
+        expect(cloned.car).to eq(subject.car)
+        expect(cloned.cdr).to eq(subject.cdr)
+      end
+
+      it 'should clone a proper list' do
+        pair2 = SkmPair.new(identifier('b'), SkmEmptyList.instance)
+        pair1 = SkmPair.new(identifier('a'), pair2)
+
+        cloned = pair1.klone
+        expect(cloned.car).to eq(identifier('a'))
+        expect(cloned.cdr.car).to eq(identifier('b'))
+        expect(cloned.cdr.cdr).to be_null
+      end
+
+      it 'should clone a improper list' do
+        pair2 = SkmPair.new(identifier('b'), identifier('c'))
+        pair1 = SkmPair.new(identifier('a'), pair2)
+
+        cloned = pair1.klone
+        expect(cloned.car).to eq(identifier('a'))
+        expect(cloned.cdr.car).to eq(identifier('b'))
+        expect(cloned.cdr.cdr).to eq(identifier('c'))
+      end
+
       it 'should know its length' do
         expect(subject.length).to eq(1)
 
@@ -88,6 +114,21 @@ module Skeem
         expect(list_length_2.to_a).to eq([integer(10), sample_car])
       end
 
+      it 'should return the last pair of a proper list' do
+        expect(subject.last_pair).to eq(subject)
+
+        pair2 = SkmPair.new(identifier('b'), SkmEmptyList.instance)
+        pair1 = SkmPair.new(identifier('a'), pair2)
+        expect(pair1.last_pair).to eq(pair1)
+      end
+
+      it 'should return the last pair of an improper list' do
+        pair3 = SkmPair.new(identifier('c'), identifier('d'))
+        pair2 = SkmPair.new(identifier('b'), pair3)
+        pair1 = SkmPair.new(identifier('a'), pair2)
+        expect(pair1.last_pair).to eq(pair3)
+      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)

data/spec/skeem/skm_unary_expression_spec.rb

@@ -1,6 +1,5 @@
 require_relative '../spec_helper' # Use the RSpec framework
 require_relative '../../lib/skeem/datum_dsl'
-require_relative '../../lib/skeem/environment'
 require_relative '../../lib/skeem/s_expr_nodes'
 require_relative '../../lib/skeem/skm_unary_expression' # Load the classes under test
 
@@ -49,7 +48,7 @@ module Skeem
     end # context
 
     context 'Provided services:' do
-      let(:runtime) { Runtime.new(Environment.new) }
+      let(:runtime) { Runtime.new(SkmFrame.new) }
 
       # it 'should return the child(datum) at evaluation' do
         # expect(subject.evaluate(runtime)).to be_equal(subject.child)
@@ -90,7 +89,7 @@ module Skeem
     end # context
 
     context 'Provided services:' do
-      let(:runtime) { Runtime.new(Environment.new) }
+      let(:runtime) { Runtime.new(SkmFrame.new) }
 
       it 'should return the child(template) at evaluation' do
         expect(subject.evaluate(runtime)).to be_equal(subject.child)
@@ -131,7 +130,7 @@ module Skeem
     end # context
 
     context 'Provided services:' do
-      let(:runtime) { Runtime.new(Environment.new) }
+      let(:runtime) { Runtime.new(SkmFrame.new) }
 
       it 'should return the child(template) at evaluation' do
         expect(subject.evaluate(runtime)).to be_equal(subject.child)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: skeem
 version: !ruby/object:Gem::Version
-  version: 0.2.04
+  version: 0.2.05
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-04-29 00:00:00.000000000 Z
+date: 2019-05-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley
@@ -86,7 +86,6 @@ files:
 - lib/skeem.rb
 - lib/skeem/datum_dsl.rb
 - lib/skeem/element_visitor.rb
-- lib/skeem/environment.rb
 - lib/skeem/grammar.rb
 - lib/skeem/interpreter.rb
 - lib/skeem/parser.rb
@@ -111,7 +110,6 @@ files:
 - skeem.gemspec
 - spec/skeem/datum_dsl_spec.rb
 - spec/skeem/element_visitor_spec.rb
-- spec/skeem/environment_spec.rb
 - spec/skeem/interpreter_spec.rb
 - spec/skeem/lambda_spec.rb
 - spec/skeem/parser_spec.rb
@@ -158,7 +156,6 @@ summary: Skeem is an interpreter of a subset of the Scheme programming language.
 test_files:
 - spec/skeem/datum_dsl_spec.rb
 - spec/skeem/element_visitor_spec.rb
-- spec/skeem/environment_spec.rb
 - spec/skeem/interpreter_spec.rb
 - spec/skeem/lambda_spec.rb
 - spec/skeem/parser_spec.rb

data/lib/skeem/environment.rb

@@ -1,80 +0,0 @@
-module Skeem
-  class Environment
-    attr_reader :outer
-
-    attr_reader(:bindings)
-
-    def initialize(outerEnv = nil)
-      @bindings = {}
-      @outer = outerEnv
-    end
-
-    def define(anIdentifier, anExpression)
-      raise StandardError, anIdentifier unless anIdentifier.kind_of?(String)
-      @bindings[anIdentifier] = anExpression
-    end
-
-    def fetch(anIdentifier)
-      found = bindings[anIdentifier]
-      if found.nil? && outer
-        found = outer.fetch(anIdentifier)
-      end
-
-      found
-    end
-
-    def empty?
-      my_result = bindings.empty?
-      if my_result && outer
-        my_result = outer.empty?
-      end
-
-      my_result
-    end
-
-    def size
-      my_result = bindings.size
-      my_result += outer.size if outer
-
-      my_result
-    end
-
-    def include?(anIdentifier)
-      my_result = bindings.include?(anIdentifier)
-      if my_result == false  && outer
-        my_result = outer.include?(anIdentifier)
-      end
-
-      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
-
-    def inspect
-      result = ''
-      if outer
-        result << outer.inspect
-      else
-        return "\n"
-      end
-      result << "\n----\n"
-      bindings.each_pair do |key, expr|
-        result << "#{key.inspect} => #{expr.inspect}\n"
-      end
-
-      result
-    end
-  end # class
-end # module

data/spec/skeem/environment_spec.rb

@@ -1,81 +0,0 @@
-require_relative '../spec_helper' # Use the RSpec framework
-require_relative '../../lib/skeem/environment' # Load the class under test
-
-module Skeem
-  describe Environment do
-    let(:sample_env) { Environment.new }
-    context 'Initialization:' 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
-      it 'should add entries' do
-        entry = double('dummy')
-        subject.define('dummy', entry)
-        expect(subject.size).to eq(1)
-        expect(subject.bindings['dummy']).not_to be_nil
-        expect(subject.bindings['dummy']).to eq(entry)
-      end
-
-      it 'should know whether it is empty' do
-        # Case 1: no entry
-        expect(subject.empty?).to be_truthy
-
-        # Case 2: existing entry
-        entry = double('dummy')
-        subject.define('dummy', entry)
-        expect(subject.empty?).to be_falsey
-
-        # Case 3: entry defined in outer environment
-        nested = Environment.new(subject)
-        expect(nested.empty?).to be_falsey
-      end
-
-      it 'should retrieve entries' do
-        # Case 1: non-existing entry
-        expect(subject.fetch('dummy')).to be_nil
-
-        # Case 2: existing entry
-        entry = double('dummy')
-        subject.define('dummy', entry)
-        expect(subject.fetch('dummy')).to eq(entry)
-
-        # Case 3: entry defined in outer environment
-        nested = Environment.new(subject)
-        expect(nested.fetch('dummy')).to eq(entry)
-      end
-
-      it 'should know the total number of bindings' do
-        # Case 1: non-existing entry
-        expect(subject.size).to be_zero
-
-        # Case 2: existing entry
-        entry = double('dummy')
-        subject.define('dummy', entry)
-        expect(subject.size).to eq(1)
-
-        # Case 3: entry defined in outer environment
-        nested = Environment.new(subject)
-        expect(nested.size).to eq(1)
-      end
-    end # context
-
-  end # describe
-end # module