skeem 0.1.03 → 0.2.00

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 378523b0249fe580ce581ba771a6fb89e1b9e8845489629b81930adecccf2907
-  data.tar.gz: de3a44c40bb82810c3dbaa7b97d70de40d8d0149c157bc97fdd7e74c8e4e44cb
+  metadata.gz: 4f8a75ad0a0ead374dc7ec59e94abc9edd04826901be7f2e8230c9047c256845
+  data.tar.gz: 854f4e2e64dff8224046420ee7ccd035b23cf409c016ecec667206c02a5aae87
 SHA512:
-  metadata.gz: 6189770ed0e2cd852d30a80d87ff9947c43a7c43afa64f4673ca1ce7208d5967b864a6e62dc9a20fd9ad0ca3115e6f31e77058038bf7c4f523f110dcae50a162
-  data.tar.gz: 6fe2efbf1e8618df9af68c08ea62abbb4cb66d52a45019be4f6e5961be418044a60091e41e1c7fad4da27d1d396e23ae4bb2e6fb6b52dca89b8db0f1f395c748
+  metadata.gz: ea925e74fbbab68290d6b6cb13e7af3caa735e9f5709e5d9f50423410695d5db0a9c50d077e594e2683e16c7b4f6b85c02b1d72629d97dc6e9348f7a1e32533c
+  data.tar.gz: 4930db824c351c76d56f006491f8838e88b64e2e2200fb13412c848c0bc90c6f9effa839983ac3e5bd926e0c0ab162bfb87e3a8217f8d2f14410ce35a4ff2d46

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [0.1.04] - 2019-01-19
+### Added
+- Method `SkmDefinition#redefine`: a given variable can point to another expression.
+
+### Fixed
+- Procedure `set!` caused infinite loops when redefinition involved a procedure call.
+
 ## [0.1.03] - 2019-01-15
 ### Added
 - File `base.skm` implementation of list procedures: `caar`, `cadr`, `cdar`, `cddr`

data/README.md

@@ -222,7 +222,7 @@ This project is intended to be a safe, welcoming space for collaboration, and co
 
 Copyright
 ---------
-Copyright (c) 2018, Dimitri Geshef.  
+Copyright (c) 2018-2019, Dimitri Geshef.  
 __Skeem__ is released under the MIT License see [LICENSE.txt](https://github.com/famished-tiger/Skeem/blob/master/LICENSE.txt) for details.
 
 ## Code of Conduct

data/lib/skeem/grammar.rb

@@ -20,8 +20,8 @@ module Skeem
 
     # Keywords...
     add_terminals('DEFINE', 'IF', 'LAMBDA')
-    add_terminals('QUOTE', 'QUASIQUOTE', 'UNQUOTE')
-    add_terminals('UNQUOTE-SPLICING')
+    add_terminals('QUOTE', 'QUASIQUOTE', 'SET!')
+    add_terminals('UNQUOTE', 'UNQUOTE-SPLICING')
 
     rule('program' => 'cmd_or_def_plus').as 'main'
     rule('cmd_or_def_plus' => 'cmd_or_def_plus cmd_or_def').as 'multiple_cmd_def'
@@ -36,6 +36,7 @@ module Skeem
     rule 'expression' =>  'procedure_call'
     rule 'expression' =>  'lambda_expression'
     rule 'expression' =>  'conditional'
+    rule 'expression' =>  'assignment'    
     rule 'expression' =>  'derived_expression'
     rule 'literal' => 'quotation'
     rule 'literal' => 'self-evaluating'
@@ -90,6 +91,7 @@ module Skeem
     rule 'alternate' => []
     rule 'number' => 'INTEGER'
     rule 'number' => 'REAL'
+    rule('assignment' => 'LPAREN SET! IDENTIFIER expression RPAREN').as 'assignment'
     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/interpreter.rb

@@ -1,5 +1,5 @@
 require_relative 'parser'
-require_relative 'environment'
+require_relative 'skm_frame'
 require_relative 'runtime'
 require_relative './primitive/primitive_builder'
 
@@ -9,31 +9,46 @@ module Skeem
     attr_reader(:parser)
     attr_reader(:runtime)
 
-    def initialize()
-      @runtime = Runtime.new(Environment.new)
+    def initialize(&aBlock)
+      @runtime = Runtime.new(SkmFrame.new)
+      @parser = Parser.new
+
+      if block_given?
+        yield self
+      else
+        add_default_procedures
+      end
+    end
+
+    def add_default_procedures()
       add_primitives(runtime)
       add_standard(runtime)
     end
 
-    def run(source, mode = nil)
+    def parse(source, mode = nil)
       @parser ||= Parser.new
       @ptree = parser.parse(source)
       # $stderr.puts @ptree.root.inspect if mode.nil?
-      # require 'debug' if mode.nil?
-      return @ptree.root.evaluate(runtime)
+      # require 'debug' unless mode.nil?      
+    end
+    
+    def run(source, mode = nil)
+      parse(source, mode)
+      # require 'debug' unless mode.nil?       
+      @ptree.root.evaluate(runtime)
     end
 
     def fetch(anIdentifier)
       runtime.environment.fetch(anIdentifier)
     end
 
-    private
-
-    def add_standard(aRuntime)
+    def add_standard(_runtime)
       std_pathname = File.dirname(__FILE__) + '/standard/base.skm'
       load_lib(std_pathname)
     end
 
+    private
+
     def load_lib(aPathname)
       lib_source = nil
       File.open(aPathname, 'r') do |lib|

data/lib/skeem/primitive/primitive_builder.rb

@@ -48,7 +48,6 @@ module Skeem
       end
 
       def add_binding(aRuntime)
-        create_set!(aRuntime)
       end
 
       def add_arithmetic(aRuntime)
@@ -123,21 +122,9 @@ module Skeem
       end
 
       def add_special_procedures(aRuntime)
-        create_assert(aRuntime)
+        create_test_assert(aRuntime)
         create_debug(aRuntime)
-      end
-
-      def create_set!(aRuntime)
-          primitive = ->(runtime, var_ref, expr) do
-            if runtime.include?(var_ref.child)
-              redefinition = SkmDefinition.new(nil, var_ref.child, expr)
-              redefinition.evaluate(runtime)
-            else
-              raise StandardError, "Unbound variable: '#{var.value}'"
-            end
-        end
-
-        define_primitive_proc(aRuntime, 'set!', binary, primitive)
+        create_inspect(aRuntime)
       end
 
       def create_plus(aRuntime)
@@ -622,7 +609,7 @@ module Skeem
         define_primitive_proc(aRuntime, 'newline', nullary, primitive)
       end
 
-      def create_assert(aRuntime)
+      def create_test_assert(aRuntime)
         primitive = ->(runtime, arg) do
           arg_evaluated = arg.evaluate(runtime)
           if arg_evaluated.boolean? && arg_evaluated.value == false
@@ -636,9 +623,11 @@ module Skeem
           end
         end
 
-        define_primitive_proc(aRuntime, 'assert', unary, primitive)
+        define_primitive_proc(aRuntime, 'test-assert', unary, primitive)
       end
 
+      # DON'T USE IT
+      # Non-standard procedure reserved for internal testing/debugging purposes.      
       def create_debug(aRuntime)
         primitive = ->(runtime) do
           require 'debug'
@@ -646,6 +635,17 @@ module Skeem
 
         define_primitive_proc(aRuntime, 'debug', nullary, primitive)
       end
+      
+      # DON'T USE IT
+      # Non-standard procedure reserved for internal testing/debugging purposes.
+      def create_inspect(aRuntime)
+        primitive = ->(runtime, arg) do
+          arg_evaluated = arg.evaluate(runtime)
+          $stderr.puts 'INSPECT>' + arg_evaluated.inspect
+          Skeem::SkmUndefined.instance
+        end
+        define_primitive_proc(aRuntime, '_inspect', unary, primitive)      
+      end
 
       def create_object_predicate(aRuntime, predicate_name, msg_name = nil)
         msg_name = predicate_name if msg_name.nil?
@@ -670,7 +670,7 @@ module Skeem
       end
 
       def define(aRuntime, aKey, anEntry)
-        aRuntime.define(aKey, anEntry)
+        aRuntime.add_binding(aKey, anEntry)
       end
 
       def evaluate_arguments(arglist, aRuntime)

data/lib/skeem/primitive/primitive_procedure.rb

@@ -14,18 +14,44 @@ module Skeem
         @arity = arity_validated(anArity)
       end
 
+      def callable?
+        true
+      end
+
+      # This method should be invoked when the procedure isn't
+      # explicitly called (with arguments). In this case, the name
+      # of procedure just returns the procedure object itself.
+      # @param _runtime [Runtime]
+      # @return [PrimitiveProcedure]
+      def evaluate(_runtime)
+        self
+      end
+
       # Arguments are positional in a primitive procedure.
-      def call(aRuntime, aProcedureCall)
-        actuals = aProcedureCall.operands.to_a
+      # @param theActuals [Array<SkmElement>]
+      def call(aRuntime, theActuals)
+        actuals = theActuals
+        # $stderr.puts "--- Start of procedure #{identifier}"
+        # actuals.each { |actual| $stderr.puts '  Actual: ' + actual.inspect }
         check_actual_count(actuals)
-        aProcedureCall.operands_consumed = true
-        do_call(aRuntime, actuals)
+        # TODO: check that next line became useless
+        # aProcedureCall.operands_consumed = true
+        result = do_call(aRuntime, actuals)
+        # $stderr.puts "  Result: #{result.inspect}"
+        # $stderr.puts "--- End of procedure #{identifier}"
+        result
       end
-      
+
       def skm_equal?(other)
         equal?(other)
       end
 
+      # Notification that this procedure is bound to a variable
+      # @param [Skemm::SkmFrame]
+      def bound!(_frame)
+        # Do nothing
+      end
+
       private
 
       def code_validated(aRubyLambda)
@@ -94,7 +120,7 @@ module Skeem
             #p count_delta
             #p arguments.inspect
             result = code.send(:call, aRuntime, *arguments.flatten)
-          end       
+          end
         else # Fixed arity...
           result = code.send(:call, aRuntime, *operands)
         end

data/lib/skeem/runtime.rb

@@ -1,30 +1,37 @@
 require_relative 's_expr_nodes'
-require_relative 'environment'
 
 module Skeem
   class Runtime
-    # @return [Environment]
-    attr_reader(:environment)
+    # @return [Array<SkmFrame>] The current active frame
+    attr_reader(:env_stack)
 
     # @return [Array<ProcedureCall>] The call stack
     attr_reader(:call_stack)
 
-    def initialize(anEnvironment)
-      @environment = anEnvironment
-      @call_stack = []
+    def initialize(anEnvironment, parent = nil)
+      @env_stack = []
+      push(anEnvironment)
+      @call_stack = parent.nil? ? [] : parent.call_stack
+    end
+
+    def environment
+      env_stack.last
     end
 
     def include?(anIdentifier)
-      environment.include?(normalize_key(anIdentifier))
+      environment.include?(anIdentifier)
     end
 
     def fetch(aKey)
-      key_value = normalize_key(aKey)
-      include?(key_value) ? environment.fetch(key_value) : nil
+      include?(aKey) ? environment.fetch(aKey) : nil
     end
 
-    def define(aKey, anEntry)
-      environment.define(normalize_key(aKey), anEntry)
+    def add_binding(aKey, anEntry)
+      environment.add_binding(aKey, anEntry)
+    end
+
+    def update_binding(aKey, anEntry)
+      environment.update_binding(aKey, anEntry)
     end
 
     def evaluate(aKey)
@@ -33,14 +40,8 @@ module Skeem
         entry = environment.fetch(key_value)
         result = nil
         begin
-          case entry
-            when Primitive::PrimitiveProcedure
-              result = entry
-            when SkmDefinition
-              result = entry.expression.evaluate(self)
-            else
-              raise StandardError, entry.inspect
-          end
+          result = entry.evaluate(self)
+
         rescue NoMethodError => exc
           # $stderr.puts 'In rescue block'
           # $stderr.puts key_value.inspect
@@ -66,29 +67,30 @@ module Skeem
     end
 
     def nest()
-      nested = Environment.new(environment)
-      @environment = nested
+      nested = SkmFrame.new(environment)
+      push(nested)
     end
 
-    def unnest()
-      raise StandardError, 'Cannot unnest environment' unless environment.outer
+    def unnest
+      raise StandardError, 'Cannot unnest environment' unless environment.parent
       environment.bindings.clear
-      @environment = environment.outer
+      pop
     end
 
-    def depth()
-      return environment.depth
+    def depth
+      return env_stack.size
     end
 
     def push(anEnvironment)
-      @environment = anEnvironment
+      env_stack.push(anEnvironment)
     end
 
-    # Make the outer enviromnent thecurrent one inside the provided block
+    # Make the parent frame the current one inside the provided block
     def pop
-      env = environment
-      @environment = environment.outer
-      env
+      if env_stack.empty?
+        raise StandardError, 'Skeem environment stack empty!'
+      end
+      env_stack.pop
     end
 
     def push_call(aProcCall)
@@ -104,7 +106,7 @@ module Skeem
       # $stderr.puts 'CALL STACK ^^^^'
     end
 
-    def pop_call()
+    def pop_call
       if call_stack.empty?
         raise StandardError, 'Skeem call stack empty!'
       end

data/lib/skeem/s_expr_builder.rb

@@ -1,5 +1,6 @@
 require 'stringio'
 require_relative 'skm_pair'
+require_relative 'skm_binding'
 require_relative 's_expr_nodes'
 
 module Skeem
@@ -60,8 +61,8 @@ module Skeem
 
     # rule('definition' => 'LPAREN DEFINE IDENTIFIER expression RPAREN')
     #  .as 'definition'
-    def reduce_definition(_production, aRange, _tokens, theChildren)
-      SkmDefinition.new(aRange, theChildren[2], theChildren[3])
+    def reduce_definition(_production, _range, _tokens, theChildren)
+      SkmBinding.new(theChildren[2], theChildren[3])
     end
 
     # rule('definition' => 'LPAREN DEFINE LPAREN IDENTIFIER def_formals RPAREN body RPAREN').as 'alt_definition'
@@ -69,7 +70,7 @@ module Skeem
     def reduce_alt_definition(_production, aRange, _tokens, theChildren)
       lmbd = SkmLambda.new(aRange, theChildren[4], theChildren[6])
       # $stderr.puts lmbd.inspect
-      SkmDefinition.new(aRange, theChildren[3], lmbd)
+      SkmBinding.new(theChildren[3], lmbd)
     end
 
     # rule('expression' =>  'IDENTIFIER').as 'variable_reference'
@@ -245,6 +246,11 @@ module Skeem
     def reduce_conditional(_production, aRange, _tokens, theChildren)
       SkmCondition.new(aRange, theChildren[2], theChildren[3], theChildren[4])
     end
+    
+    # rule('assignment' => 'LPAREN SET! IDENTIFIER expression RPAREN').as 'assignment'
+    def reduce_assignment(_production, _range, _tokens, theChildren)
+      SkmUpdateBinding.new(theChildren[2], theChildren[3])
+    end
 
     # rule('quasiquotation' => 'LPAREN QUASIQUOTE qq_template RPAREN').as 'quasiquotation'
     def reduce_quasiquotation(_production, aRange, _tokens, theChildren)

data/lib/skeem/s_expr_nodes.rb

@@ -8,26 +8,17 @@ require_relative 'skm_unary_expression'
 module Skeem
   class SkmUndefined
     include Singleton
-    
+
     def value
-      :UNDEFINED
+      self
     end
 
     def ==(other)
-      return true if other.kind_of?(SkmUndefined)
-
-      result = case other
-        when Symbol
-          self.value == other
-        when String
-          self.value.to_s == other
-        else
-          raise StandardError, other.inspect
-      end
+      equal?(other)
     end
-    
+
     private
-    
+
     def initialize
       self.freeze
     end
@@ -46,95 +37,13 @@ module Skeem
     end
   end
 
-  class SkmDefinition < SkmMultiExpression
-    attr_reader :variable
-    attr_reader :expression
-
-    def initialize(aPosition, aVariable, theExpression)
-      super(aPosition)
-      @variable = aVariable
-      @expression = theExpression
-      unless expression.kind_of?(SkmElement)
-        raise StandardError, "Bad definition"
-      end
-    end
-
-    def evaluate(aRuntime)
-      var_key = variable.evaluate(aRuntime)
-      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
-            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
-
-      result
-    end
-
-    def quasiquote(aRuntime)
-      quasi_var = variable.quasiquote(aRuntime)
-      quasi_expression = variable.quasiquote(aRuntime)
-
-      if quasi_var.equal?(variable) && quasi_expression.equal?(expression)
-        self
-      else
-        self.class.new(position, quasi_var, quasi_expression)
-      end
-    end
-
-    # call method should only invoked when the expression is a SkmLambda
-    def call(aRuntime, aProcedureCall)
-      expr = expression
-      expr = expr.evaluate(aRuntime) if expr.kind_of?(SkmVariableReference)
-      unless [SkmLambda, Primitive::PrimitiveProcedure].include?(expr.class)
-        err_msg = "Expected a SkmLambda instead of #{expr.class}"
-        raise StandardError, err_msg
-      end
-      # $stderr.puts "SkmDefinition#call #{aProcedureCall.inspect}"
-      expr.call(aRuntime, aProcedureCall)
-    end
-
-    def inspect
-      result = inspect_prefix
-      result << variable.inspect
-      result << ', '
-      result << expression.inspect
-      result << inspect_suffix
-      result
-    end
-
-    def associations
-      [:variable, :expression]
-    end
-  end # class
-
   class ProcedureCall < SkmMultiExpression
     attr_reader :operator
     attr_reader :operands
+
     attr_accessor :call_site
+
+    # @return [FalseClass, TrueClass] True if all arguments are used by callee.
     attr_accessor :operands_consumed
 
     def initialize(aPosition, anOperator, theOperands)
@@ -154,48 +63,32 @@ module Skeem
     end
 
     def evaluate(aRuntime)
+      frame_change = false
       aRuntime.push_call(self)
-      if operator.kind_of?(SkmLambda)
-        callee = operator
-      else
-        var_key = operator.evaluate(aRuntime)
-        if operator.kind_of?(ProcedureCall)
-          return var_key if operands_consumed
-        end
-        if var_key.kind_of?(Primitive::PrimitiveProcedure)
-          callee = var_key
-        else
-          begin
-            aRuntime.include?(var_key.value)
-          rescue NoMethodError => exc
-            # $stderr.puts "VVVVVVVVVVVVVVV"
-            # $stderr.puts 'var_key: ' + var_key.inspect
-            # $stderr.puts 'operator: ' + operator.inspect
-            # $stderr.puts 'operands: ' + operands.inspect
-            # $stderr.puts 'operands_consumed: ' + operands_consumed.inspect
-            # $stderr.puts "^^^^^^^^^^^^^^^"
-            raise exc
-          end
-          unless aRuntime.include?(var_key.value)
-            err = StandardError
-            key = var_key.kind_of?(SkmIdentifier) ? var_key.value : var_key
-            err_msg = "Unknown procedure '#{key}'"
-            raise err, err_msg
-          end
-          callee = aRuntime.environment.fetch(var_key.value)
-        end
-        unless var_key.nil?
-          # $stderr.puts "## In ProcCall #{var_key.value} #############"
-          # $stderr.puts 'operator: ' + operator.inspect
-          # $stderr.puts 'operands: ' + operands.inspect
-          # $stderr.puts "## CALL(#{var_key.value}) ###################"
-          # $stderr.puts 'callee: ' + callee.inspect
-        end
+      # $stderr.puts "\n Start of ProcedureCall#evaluate #{object_id.to_s(16)}"
+      # $stderr.puts "  environment: #{aRuntime.environment.object_id.to_s(16)}, "
+      if aRuntime.environment && aRuntime.environment.parent
+        # $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
+      actuals = transform_operands(aRuntime)
+      #$stderr.puts '  transformed operands: ' + actuals.inspect
+      outcome, result = determine_callee(aRuntime)
+      if outcome == :callee
+        callee = result
+        # if callee.kind_of?(SkmLambda)
+          # aRuntime.push(callee.environment)
+          # frame_change = true
+        # end
+        # $stderr.puts '  callee: ' + callee.inspect
+        result = callee.call(aRuntime, actuals)
+        operands_consumed = true
+        # aRuntime.pop if frame_change
       end
-      result = callee.call(aRuntime, self)
-      operands_consumed = true
       aRuntime.pop_call
-      # $stderr.puts "## RETURN #{result.inspect} from #{var_key.value}"
+      # $stderr.puts "\n End of ProcedureCall#evaluate #{object_id.to_s(16)}"
       result
     end
 
@@ -217,6 +110,78 @@ module Skeem
     end
 
     alias children operands
+
+    private
+
+    def determine_callee(aRuntime)
+      case operator
+        when SkmIdentifier
+          callee = fetch_callee(aRuntime, operator)
+        when ProcedureCall
+          result = operator.evaluate(aRuntime)
+          # If child proc call consumes the parent's operand, then we're done
+          return [:result, result] unless result.callable? # if operands_consumed
+          callee = result
+          # callee = fetch_callee(aRuntime, result)
+        when Primitive::PrimitiveProcedure
+          callee = operator
+        when SkmLambda
+          callee = operator
+        else
+          result = operator.evaluate(aRuntime)
+          callee = fetch_callee(aRuntime, result)
+      end
+
+      [:callee, callee]
+    end
+
+    def fetch_callee(aRuntime, var_key)
+      begin
+        aRuntime.include?(var_key.value)
+      rescue NoMethodError => exc
+        # $stderr.puts "VVVVVVVVVVVVVVV"
+        # $stderr.puts 'var_key: ' + var_key.inspect
+        # $stderr.puts 'operator: ' + operator.inspect
+        # $stderr.puts 'operands: ' + operands.inspect
+        # $stderr.puts 'operands_consumed: ' + operands_consumed.inspect
+        # $stderr.puts "^^^^^^^^^^^^^^^"
+        raise exc
+      end
+      unless aRuntime.include?(var_key.value)
+        err = StandardError
+        key = var_key.kind_of?(SkmIdentifier) ? var_key.value : var_key
+        err_msg = "Unknown procedure '#{key}'"
+        # $stderr.puts aRuntime.inspect
+        # $stderr.puts aRuntime.environment.size.inspect
+        raise err, err_msg
+      end
+      callee = aRuntime.environment.fetch(var_key.value)
+      # $stderr.puts "## CALL(#{var_key.value}) ###################"
+      # $stderr.puts 'callee: ' + callee.inspect
+      # $stderr.puts 'operator: ' + operator.inspect
+      # $stderr.puts 'operands: ' + operands.inspect
+
+      callee
+    end
+
+    def transform_operands(aRuntime)
+      return [] if operands == SkmEmptyList.instance
+      actuals = operands.to_a
+
+      result = actuals.map do |actual|
+        case actual
+          when SkmVariableReference
+            aRuntime.fetch(actual.child)
+          else
+            actual.evaluate(aRuntime)
+        end
+      end
+
+      result.nil? ? [] : result
+    end
+
+
+
   end # class
 
   class SkmCondition < SkmMultiExpression
@@ -331,6 +296,10 @@ module Skeem
     end
   end # class
 
+
+
+require_relative 'skm_procedure_exec'
+
   class SkmLambda < SkmMultiExpression
     include DatumDSL
 
@@ -339,6 +308,7 @@ module Skeem
     attr_reader :formals
     attr_reader :definitions
     attr_reader :sequence
+    attr_reader :environment
 
     def initialize(aPosition, theFormals, aBody)
       super(aPosition)
@@ -348,9 +318,12 @@ module Skeem
     end
 
     def evaluate(aRuntime)
-      # formals.evaluate(aRuntime)
       self
     end
+
+    def callable?
+      true
+    end
 =begin
   TODO
     def quasiquote(aRuntime)
@@ -361,17 +334,28 @@ module Skeem
        self.class.new(position, quasi_test, quasi_consequent, quasi_alternate)
     end
 =end
-    def call(aRuntime, aProcedureCall)
+    def call(aRuntime, theActuals)
+      set_cond_environment(aRuntime.environment) # Last chance for anonymous lambda
+      application = SkmProcedureExec.new(self)
+      application.run!(aRuntime, theActuals)
+=begin
+      # $stderr.puts "Start of lambda #{object_id.to_s(16)}"
       aRuntime.nest
+      # $stderr.puts '  Before bind_locals'
       bind_locals(aRuntime, aProcedureCall)
+      # $stderr.puts '  After bind_locals'
       # $stderr.puts 'LOCALS vvvvvvvvvvv'
       # $stderr.puts aRuntime.environment.inspect
       # $stderr.puts 'LOCALS ^^^^^^^^^^^'
       result = evaluate_defs(aRuntime)
+      # $stderr.puts '  Before evaluate_sequence'
       result = evaluate_sequence(aRuntime)
+      # $stderr.puts '  After evaluate_sequence'
       aRuntime.unnest
-
+      # $stderr.puts "  Result: #{result.inspect}"
+      # $stderr.puts "End of lambda #{object_id.to_s(16)}"
       result
+=end
     end
 
     def arity
@@ -385,10 +369,14 @@ module Skeem
     alias eqv? equal?
     alias skm_equal? equal?
 
+    def bound!(aFrame)
+      set_cond_environment(aFrame)
+    end
+
     def inspect
-      result = inspect_prefix + '@formals ' + formals.inspect + ', '
-      result << '@definitions ' + definitions.inspect + ', '
-      result << '@sequence ' + sequence.inspect + inspect_suffix
+      result = inspect_prefix + "@object_id=#{object_id.to_s(16)}, "
+      result << inspect_specific
+      result << inspect_suffix
       result
     end
 
@@ -396,18 +384,18 @@ module Skeem
       [:formals, :definitions, :sequence]
     end
 
-    private
-
-    def bind_locals(aRuntime, aProcedureCall)
-      actuals =  aProcedureCall.operands.to_a
+    def bind_locals(aRuntime, theActuals)
+      actuals =  theActuals
       count_actuals = actuals.size
 
       if (count_actuals < required_arity) ||
         ((count_actuals > required_arity) && !formals.variadic?)
-        raise StandardError, msg_arity_mismatch(aProcedureCall)
+        # $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, aProcedureCall)
+      bind_required_locals(aRuntime, theActuals)
       if formals.variadic?
         variadic_part_raw = actuals.drop(required_arity)
         variadic_part = variadic_part_raw.map do |actual|
@@ -422,14 +410,17 @@ module Skeem
         end
         variadic_arg_name = formals.formals.last
         args_coll = SkmPair.create_from_a(variadic_part)
-        a_def = SkmDefinition.new(position, variadic_arg_name, args_coll)
+        # a_def = SkmDefinition.new(position, variadic_arg_name, args_coll)
+        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)
+        # a_def.evaluate(aRuntime)
       end
-      aProcedureCall.operands_consumed = true
+      #aProcedureCall.operands_consumed = true
     end
 
     def evaluate_defs(aRuntime)
@@ -440,45 +431,54 @@ module Skeem
       result = nil
       if sequence
         sequence.each do |cmd|
-          if cmd.kind_of?(SkmLambda)
-            caller_index = -2
-            loop do
-              raise StandardError, "Missing argument" unless aRuntime.caller(caller_index)
-              unless aRuntime.caller(caller_index).operands_consumed
-                aRuntime.caller(caller_index).operands_consumed = true
-                result = cmd.call(aRuntime, aRuntime.caller(caller_index))
-                break
-              end
-              caller_index -= 1
-            end
-          else
-            begin
+          begin
+            if cmd.kind_of?(SkmLambda)
+              result = cmd.dup_cond(aRuntime)
+            else
               result = cmd.evaluate(aRuntime)
-            rescue NoMethodError => exc
-              $stderr.puts self.inspect
-              $stderr.puts sequence.inspect
-              $stderr.puts cmd.inspect
-              raise exc
             end
+          rescue NoMethodError => exc
+            $stderr.puts self.inspect
+            $stderr.puts sequence.inspect
+            $stderr.puts cmd.inspect
+            raise exc
           end
         end
       end
 
       result
     end
+    
+    def dup_cond(aRuntime)
+      if environment
+        result = self
+      else
+        twin = self.dup
+        twin.set_cond_environment(aRuntime.environment)
+        result = twin
+      end
+      
+      result
+    end
+
+    def set_cond_environment(theFrame)
+      # $stderr.puts "Lambda #{object_id.to_s(16)}, env [#{environment.object_id.to_s(16)}]"
+      # $stderr.puts "  Runtime environment: #{theFrame.object_id.to_s(16)}"
+      # $stderr.puts "  Called from #{caller(1, 1)}"
+      raise StandardError unless theFrame.kind_of?(SkmFrame)
+      unless environment
+        @environment = theFrame
+        self.freeze
+        # $stderr.puts "  Lambda's environment updated!"
+      end
+    end
+
+    private
 
     # Purpose: bind each formal from lambda to an actual value from the call
-    def bind_required_locals(aRuntime, aProcedureCall)
+    def bind_required_locals(aRuntime, theActuals)
       max_index = required_arity - 1
-      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
+      actuals = theActuals
       formal_names = formals.formals.map(&:value)
 
       formals.formals.each_with_index do |arg_name, index|
@@ -496,25 +496,40 @@ module Skeem
         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}"
+        # 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.define(arg_name, a_def)
+          aRuntime.add_binding(arg_name, a_def)
         else
-          a_def.evaluate(aRuntime)
+          aRuntime.add_binding(a_def.variable, a_def.evaluate(aRuntime))
         end
         break if index >= max_index
       end
     end
 
-    def msg_arity_mismatch(aProcCall)
+    def msg_arity_mismatch(actuals)
       # *** ERROR: wrong number of arguments for #<closure morph> (required 2, got 1)
-      msg1 = "Wrong number of arguments for procedure #{aProcCall.operator} "
-      count_actuals = aProcCall.operands.members.size
+      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 = "@environment #{environment.object_id.to_s(16)}, "
+      result = ''
+      if environment && environment.parent
+        result << "Parent environment #{environment.parent.object_id.to_s(16)}, "
+        result << environment.inspect
+      end
+      result << '@formals ' + formals.inspect + ', '
+      result << '@definitions ' + definitions.inspect + ', '
+      result << '@sequence ' + sequence.inspect + inspect_suffix
+
+      result
+    end
   end # class
 end # module
 # End of file