diff --git a/lib/puppet/pops/evaluator/closure.rb b/lib/puppet/pops/evaluator/closure.rb
index c63a9c890..1efb74501 100644
--- a/lib/puppet/pops/evaluator/closure.rb
+++ b/lib/puppet/pops/evaluator/closure.rb
@@ -1,228 +1,230 @@
-
 # A Closure represents logic bound to a particular scope.
-# As long as the runtime (basically the scope implementation) has the behaviour of Puppet 3x it is not
-# safe to use this closure when the scope given to it when initialized goes "out of scope".
+# As long as the runtime (basically the scope implementation) has the behavior of Puppet 3x it is not
+# safe to return and later use this closure.
 #
-# Note that the implementation is backwards compatible in that the call method accepts a scope, but this
-# scope is not used.
+# The 3x scope is essentially a named scope with an additional internal local/ephemeral nested scope state.
+# In 3x there is no way to directly refer to the nested scopes, instead, the named scope must be in a particular
+# state. Specifically, closures that require a local/ephemeral scope to exist at a later point will fail.
+# It is safe to call a closure (even with 3x scope) from the very same place it was defined, but not
+# returning it and expecting the closure to reference the scope's state at the point it was created.
 #
 # Note that this class is a CallableSignature, and the methods defined there should be used
-# as the API for obtaining information in a callable implementation agnostic way.
+# as the API for obtaining information in a callable-implementation agnostic way.
 #
 class Puppet::Pops::Evaluator::Closure < Puppet::Pops::Evaluator::CallableSignature
   attr_reader :evaluator
   attr_reader :model
   attr_reader :enclosing_scope
 
   def initialize(evaluator, model, scope)
     @evaluator = evaluator
     @model = model
     @enclosing_scope = scope
   end
 
   # marker method checked with respond_to :puppet_lambda
   # @api private
   # @deprecated Use the type system to query if an object is of Callable type, then use its signatures method for info
   def puppet_lambda()
     true
   end
 
   # Evaluates a closure in its enclosing scope after having matched given arguments with parameters (from left to right)
   # @api public
   def call(*args)
     variable_bindings = combine_values_with_parameters(args)
 
     tc = Puppet::Pops::Types::TypeCalculator
     final_args = tc.infer_set(parameters.inject([]) do |final_args, param|
       if param.captures_rest
         final_args.concat(variable_bindings[param.name])
       else
         final_args << variable_bindings[param.name]
       end
     end)
 
     if tc.callable?(type, final_args)
       @evaluator.evaluate_block_with_bindings(@enclosing_scope, variable_bindings, @model.body)
     else
       raise ArgumentError, "lambda called with mis-matched arguments\n#{Puppet::Pops::Evaluator::CallableMismatchDescriber.diff_string('lambda', final_args, [self])}"
     end
   end
 
   # Call closure with argument assignment by name
-  def call_by_name(scope, args_hash, enforce_parameters)
+  def call_by_name(args_hash, enforce_parameters)
     if enforce_parameters
       if args_hash.size > parameters.size
         raise ArgumentError, "Too many arguments: #{args_hash.size} for #{parameters.size}"
       end
 
       # associate values with parameters
       scope_hash = {}
       parameters.each do |p|
         name = p.name
         if (arg_value = args_hash[name]).nil?
           # only set result of default expr if it is defined (it is otherwise not possible to differentiate
           # between explicit undef and no default expression
           unless p.value.nil?
             scope_hash[name] = @evaluator.evaluate(p.value, @enclosing_scope)
           end
         else
           scope_hash[name] = arg_value
         end
       end
 
       missing = parameters.select { |p| !scope_hash.include?(p.name) }
       if missing.any?
         raise ArgumentError, "Too few arguments; no value given for required parameters #{missing.collect(&:name).join(" ,")}"
       end
 
       tc = Puppet::Pops::Types::TypeCalculator
       final_args = tc.infer_set(parameter_names.collect { |param| scope_hash[param] })
       if !tc.callable?(type, final_args)
         raise ArgumentError, "lambda called with mis-matched arguments\n#{Puppet::Pops::Evaluator::CallableMismatchDescriber.diff_string('lambda', final_args, [self])}"
       end
     else
       scope_hash = args_hash
     end
 
     @evaluator.evaluate_block_with_bindings(@enclosing_scope, scope_hash, @model.body)
   end
 
   def parameters
     @model.parameters
   end
 
   # Returns the number of parameters (required and optional)
   # @return [Integer] the total number of accepted parameters
   def parameter_count
     # yes, this is duplication of code, but it saves a method call
     @model.parameters.size
   end
 
   # @api public
   def parameter_names
     @model.parameters.collect(&:name)
   end
 
   # @api public
   def type
     @callable ||= create_callable_type
   end
 
   # @api public
   def last_captures_rest?
     last = @model.parameters[-1]
     last && last.captures_rest
   end
 
   # @api public
   def block_name
     # TODO: Lambda's does not support blocks yet. This is a placeholder
     'unsupported_block'
   end
 
   private
 
   def combine_values_with_parameters(args)
     variable_bindings = {}
 
     parameters.each_with_index do |parameter, index|
       param_captures     = parameter.captures_rest
       default_expression = parameter.value
 
       if index >= args.size
         if default_expression
           # not given, has default
           value = @evaluator.evaluate(default_expression, @enclosing_scope)
           if param_captures && !value.is_a?(Array)
             # correct non array default value
             value = [value]
           end
         else
           # not given, does not have default
           if param_captures
             # default for captures rest is an empty array
             value = []
           else
             @evaluator.fail(Puppet::Pops::Issues::MISSING_REQUIRED_PARAMETER, parameter, { :param_name => parameter.name })
           end
         end
       else
         given_argument = args[index]
         if param_captures
           # get excess arguments
           value = args[(parameter_count-1)..-1]
           # If the input was a single nil, or undef, and there is a default, use the default
           # This supports :undef in case it was used in a 3x data structure and it is passed as an arg
           #
           if value.size == 1 && (given_argument.nil? || given_argument == :undef) && default_expression
-            value = @evaluator.evaluate(default_expression, scope)
+            value = @evaluator.evaluate(default_expression, @enclosing_scope)
             # and ensure it is an array
             value = [value] unless value.is_a?(Array)
           end
         else
           value = given_argument
         end
       end
 
       variable_bindings[parameter.name] = value
     end
 
     variable_bindings
   end
 
   def create_callable_type()
     types = []
     range = [0, 0]
     in_optional_parameters = false
     parameters.each do |param|
       type = if param.type_expr
                @evaluator.evaluate(param.type_expr, @enclosing_scope)
              else
                Puppet::Pops::Types::TypeFactory.any()
              end
 
       if param.captures_rest && type.is_a?(Puppet::Pops::Types::PArrayType)
         # An array on a slurp parameter is how a size range is defined for a
         # slurp (Array[Integer, 1, 3] *$param). However, the callable that is
         # created can't have the array in that position or else type checking
         # will require the parameters to be arrays, which isn't what is
         # intended. The array type contains the intended information and needs
         # to be unpacked.
         param_range = type.size_range
         type = type.element_type
       elsif param.captures_rest && !type.is_a?(Puppet::Pops::Types::PArrayType)
         param_range = ANY_NUMBER_RANGE
       elsif param.value
         param_range = OPTIONAL_SINGLE_RANGE
       else
         param_range = REQUIRED_SINGLE_RANGE
       end
 
       types << type
 
       if param_range[0] == 0
         in_optional_parameters = true
       elsif param_range[0] != 0 && in_optional_parameters
         @evaluator.fail(Puppet::Pops::Issues::REQUIRED_PARAMETER_AFTER_OPTIONAL, param, { :param_name => param.name })
       end
 
       range[0] += param_range[0]
       range[1] += param_range[1]
     end
 
     if range[1] == Puppet::Pops::Types::INFINITY
       range[1] = :default
     end
 
     Puppet::Pops::Types::TypeFactory.callable(*(types + range))
   end
 
   # Produces information about parameters compatible with a 4x Function (which can have multiple signatures)
   def signatures
     [ self ]
   end
 
   ANY_NUMBER_RANGE = [0, Puppet::Pops::Types::INFINITY]
   OPTIONAL_SINGLE_RANGE = [0, 1]
   REQUIRED_SINGLE_RANGE = [1, 1]
 end
diff --git a/lib/puppet/pops/evaluator/epp_evaluator.rb b/lib/puppet/pops/evaluator/epp_evaluator.rb
index 57a95bc71..874caaf43 100644
--- a/lib/puppet/pops/evaluator/epp_evaluator.rb
+++ b/lib/puppet/pops/evaluator/epp_evaluator.rb
@@ -1,88 +1,88 @@
 # Handler of Epp call/evaluation from the epp and inline_epp functions
 #
 class Puppet::Pops::Evaluator::EppEvaluator
 
   def self.inline_epp(scope, epp_source, template_args = nil)
     unless epp_source.is_a?(String)
       raise ArgumentError, "inline_epp(): the first argument must be a String with the epp source text, got a #{epp_source.class}"
     end
 
     # Parse and validate the source
     parser = Puppet::Pops::Parser::EvaluatingParser::EvaluatingEppParser.new
     begin
       result = parser.parse_string(epp_source, 'inlined-epp-text')
     rescue Puppet::ParseError => e
       raise ArgumentError, "inline_epp(): Invalid EPP: #{e.message}"
     end
 
     # Evaluate (and check template_args)
     evaluate(parser, 'inline_epp', scope, false, result, template_args)
   end
 
   def self.epp(scope, file, env_name, template_args = nil)
     unless file.is_a?(String)
       raise ArgumentError, "epp(): the first argument must be a String with the filename, got a #{file.class}"
     end
 
     file = file + ".epp" unless file =~ /\.epp$/
     scope.debug "Retrieving epp template #{file}"
     template_file = Puppet::Parser::Files.find_template(file, env_name)
     unless template_file
       raise Puppet::ParseError, "Could not find template '#{file}'"
     end
 
     # Parse and validate the source
     parser = Puppet::Pops::Parser::EvaluatingParser::EvaluatingEppParser.new
     begin
       result = parser.parse_file(template_file)
     rescue Puppet::ParseError => e
       raise ArgumentError, "epp(): Invalid EPP: #{e.message}"
     end
 
     # Evaluate (and check template_args)
     evaluate(parser, 'epp', scope, true, result, template_args)
   end
 
   private
 
   def self.evaluate(parser, func_name, scope, use_global_scope_only, parse_result, template_args)
     template_args, template_args_set = handle_template_args(func_name, template_args)
 
     body = parse_result.body
     unless body.is_a?(Puppet::Pops::Model::LambdaExpression)
       raise ArgumentError, "#{func_name}(): the parser did not produce a LambdaExpression, got '#{body.class}'"
     end
     unless body.body.is_a?(Puppet::Pops::Model::EppExpression)
       raise ArgumentError, "#{func_name}(): the parser did not produce an EppExpression, got '#{body.body.class}'"
     end
     unless parse_result.definitions.empty?
       raise ArgumentError, "#{func_name}(): The EPP template contains illegal expressions (definitions)"
     end
 
     parameters_specified = body.body.parameters_specified
     if parameters_specified || template_args_set
       # no epp params or user provided arguments in a hash, epp() logic
       # only sees global + what was given
       closure_scope = scope.find_global_scope
       enforce_parameters = parameters_specified
     else
       # no epp params and no arguments were given => inline_epp() logic
       # sees all local variables, epp() all global
       closure_scope =  use_global_scope_only ? scope.find_global_scope : scope
       enforce_parameters = true
     end
-    evaluated_result = parser.closure(body, closure_scope).call_by_name(scope, template_args, enforce_parameters)
+    evaluated_result = parser.closure(body, closure_scope).call_by_name(template_args, enforce_parameters)
     evaluated_result
   end
 
   def self.handle_template_args(func_name, template_args)
     if template_args.nil?
       [{}, false]
     else
       unless template_args.is_a?(Hash)
         raise ArgumentError, "#{func_name}(): the template_args must be a Hash, got a #{template_args.class}"
       end
       [template_args, true]
     end
   end
 end