diff --git a/lib/puppet/functions.rb b/lib/puppet/functions.rb
index 6f4086878..f0029670c 100644
--- a/lib/puppet/functions.rb
+++ b/lib/puppet/functions.rb
@@ -1,574 +1,571 @@
 # @note WARNING: This new function API is still under development and may change at any time
 #
 # Functions in the puppet language can be written in Ruby and distributed in
 # puppet modules. The function is written by creating a file in the module's
 # `lib/puppet/functions/<modulename>` directory, where `<modulename>` is
 # replaced with the module's name. The file should have the name of the function.
 # For example, to create a function named `min` in a module named `math` create
 # a file named `lib/puppet/functions/math/min.rb` in the module.
 #
 # A function is implemented by calling {Puppet::Functions.create_function}, and
 # passing it a block that defines the implementation of the function.
 #
 # Functions are namespaced inside the module that contains them. The name of
 # the function is prefixed with the name of the module. For example,
 # `math::min`.
 #
 # @example A simple function
 #   Puppet::Functions.create_function('math::min') do
 #     def min(a, b)
 #       a <= b ? a : b
 #     end
 #   end
 #
 # Anatomy of a function
 # ---
 #
 # Functions are composed of four parts: the name, the implementation methods,
 # the signatures, and the dispatches.
 #
 # The name is the string given to the {Puppet::Functions.create_function}
 # method. It specifies the name to use when calling the function in the puppet
 # language, or from other functions.
 #
 # The implementation methods are ruby methods (there can be one or more) that
 # provide that actual implementation of the function's behavior. In the
 # simplest case the name of the function (excluding any namespace) and the name
 # of the method are the same. When that is done no other parts (signatures and
 # dispatches) need to be used.
 #
 # Signatures are a way of specifying the types of the function's parameters.
 # The types of any arguments will be checked against the types declared in the
 # signature and an error will be produced if they don't match. The types are
 # defined by using the same syntax for types as in the puppet language.
 #
 # Dispatches are how signatures and implementation methods are tied together.
 # When the function is called, puppet searches the signatures for one that
 # matches the supplied arguments. Each signature is part of a dispatch, which
 # specifies the method that should be called for that signature. When a
 # matching signature is found, the corrosponding method is called.
 #
 # Documentation for the function should be placed as comments to the
 # implementation method(s).
 #
 # @todo Documentation for individual instances of these new functions is not
 #   yet tied into the puppet doc system.
 #
 # @example Dispatching to different methods by type
 #   Puppet::Functions.create_function('math::min') do
 #     dispatch :numeric_min do
 #       param 'Numeric', 'a'
 #       param 'Numeric', 'b'
 #     end
 #
 #     dispatch :string_min do
 #       param 'String', 'a'
 #       param 'String', 'b'
 #     end
 #
 #     def numeric_min(a, b)
 #       a <= b ? a : b
 #     end
 #
 #     def string_min(a, b)
 #       a.downcase <= b.downcase ? a : b
 #     end
 #   end
 #
 # Specifying Signatures
 # ---
 #
 # If nothing is specified, the number of arguments given to the function must
 # be the same as the number of parameters, and all of the parameters are of
 # type 'Any'.
 #
 # To express that the last parameter captures the rest, the method
 # `last_captures_rest` can be called. This indicates that the last parameter is
 # a varargs parameter and will be passed to the implementing method as an array
 # of the given type.
 #
 # When defining a dispatch for a function, the resulting dispatch matches
 # against the specified argument types and min/max occurrence of optional
 # entries. When the dispatch makes the call to the implementation method the
 # arguments are simply passed and it is the responsibility of the method's
 # implementor to ensure it can handle those arguments (i.e. there is no check
 # that what was declared as optional actually has a default value, and that
 # a "captures rest" is declared using a `*`).
 #
 # @example Varargs
 #   Puppet::Functions.create_function('foo') do
 #     dispatch :foo do
 #       param 'Numeric', 'first'
 #       param 'Numeric', 'values'
 #       last_captures_rest
 #     end
 #
 #     def foo(first, *values)
 #       # do something
 #     end
 #   end
 #
 # Access to Scope
 # ---
 # In general, functions should not need access to scope; they should be
 # written to act on their given input only. If they absolutely must look up
 # variable values, they should do so via the closure scope (the scope where
 # they are defined) - this is done by calling `closure_scope()`.
 #
 # Calling other Functions
 # ---
 # Calling other functions by name is directly supported via
 # {Puppet::Pops::Functions::Function#call_function}. This allows a function to
 # call other functions visible from its loader.
 #
 # @api public
 module Puppet::Functions
   # @param func_name [String, Symbol] a simple or qualified function name
   # @param block [Proc] the block that defines the methods and dispatch of the
   #   Function to create
   # @return [Class<Function>] the newly created Function class
   #
   # @api public
   def self.create_function(func_name, function_base = Function, &block)
     if function_base.ancestors.none? { |s| s == Puppet::Pops::Functions::Function }
       raise ArgumentError, "Functions must be based on Puppet::Pops::Functions::Function. Got #{function_base}"
     end
 
     func_name = func_name.to_s
     # Creates an anonymous class to represent the function
     # The idea being that it is garbage collected when there are no more
     # references to it.
     #
     the_class = Class.new(function_base, &block)
 
     # Make the anonymous class appear to have the class-name <func_name>
     # Even if this class is not bound to such a symbol in a global ruby scope and
     # must be resolved via the loader.
     # This also overrides any attempt to define a name method in the given block
     # (Since it redefines it)
     #
     # TODO, enforce name in lower case (to further make it stand out since Ruby
     # class names are upper case)
     #
     the_class.instance_eval do
       @func_name = func_name
       def name
         @func_name
       end
     end
 
     # Automatically create an object dispatcher based on introspection if the
     # loaded user code did not define any dispatchers. Fail if function name
     # does not match a given method name in user code.
     #
     if the_class.dispatcher.empty?
       simple_name = func_name.split(/::/)[-1]
       type, names = default_dispatcher(the_class, simple_name)
       last_captures_rest = (type.size_range[1] == Puppet::Pops::Types::INFINITY)
       the_class.dispatcher.add_dispatch(type, simple_name, names, nil, nil, nil, last_captures_rest)
     end
 
     # The function class is returned as the result of the create function method
     the_class
   end
 
   # Creates a default dispatcher configured from a method with the same name as the function
   #
   # @api private
   def self.default_dispatcher(the_class, func_name)
     unless the_class.method_defined?(func_name)
       raise ArgumentError, "Function Creation Error, cannot create a default dispatcher for function '#{func_name}', no method with this name found"
     end
     any_signature(*min_max_param(the_class.instance_method(func_name)))
   end
 
   # @api private
   def self.min_max_param(method)
     # Ruby 1.8.7 does not have support for details about parameters
     if method.respond_to?(:parameters)
       result = {:req => 0, :opt => 0, :rest => 0 }
       # TODO: Optimize into one map iteration that produces names map, and sets
       # count as side effect
       method.parameters.each { |p| result[p[0]] += 1 }
       from = result[:req]
       to = result[:rest] > 0 ? :default : from + result[:opt]
       names = method.parameters.map {|p| p[1].to_s }
     else
       # Cannot correctly compute the signature in Ruby 1.8.7 because arity for
       # optional values is screwed up (there is no way to get the upper limit),
       # an optional looks the same as a varargs In this case - the failure will
       # simply come later when the call fails
       #
       arity = method.arity
       from = arity >= 0 ? arity : -arity -1
       to = arity >= 0 ? arity : :default  # i.e. infinite (which is wrong when there are optional - flaw in 1.8.7)
       names = [] # no names available
     end
     [from, to, names]
   end
 
   # Construct a signature consisting of Object type, with min, and max, and given names.
   # (there is only one type entry).
   #
   # @api private
   def self.any_signature(from, to, names)
     # Construct the type for the signature
     # Tuple[Object, from, to]
     factory = Puppet::Pops::Types::TypeFactory
     [factory.callable(factory.any, from, to), names]
   end
 
   # Function
   # ===
   # This class is the base class for all Puppet 4x Function API functions. A
   # specialized class is created for each puppet function.
   #
   # @api public
   class Function < Puppet::Pops::Functions::Function
 
     # @api private
     def self.builder
       @type_parser ||= Puppet::Pops::Types::TypeParser.new
       @all_callables ||= Puppet::Pops::Types::TypeFactory.all_callables
       DispatcherBuilder.new(dispatcher, @type_parser, @all_callables)
     end
 
     # Dispatch any calls that match the signature to the provided method name.
     #
     # @param meth_name [Symbol] The name of the implementation method to call
     #   when the signature defined in the block matches the arguments to a call
     #   to the function.
     # @return [Void]
     #
     # @api public
     def self.dispatch(meth_name, &block)
       builder().instance_eval do
         dispatch(meth_name, &block)
       end
     end
   end
 
   # Public api methods of the DispatcherBuilder are available within dispatch()
   # blocks declared in a Puppet::Function.create_function() call.
   #
   # @api public
   class DispatcherBuilder
     # @api private
     def initialize(dispatcher, type_parser, all_callables)
       @type_parser = type_parser
       @all_callables = all_callables
       @dispatcher = dispatcher
     end
 
     # Defines a positional parameter with type and name
     #
     # @param type [String] The type specification for the parameter.
     # @param name [String] The name of the parameter. This is primarily used
     #   for error message output and does not have to match the name of the
     #   parameter on the implementation method.
     # @return [Void]
     #
     # @api public
     def param(type, name)
       raise ArgumentError, 'Parameters cannot be added after a block_param' unless @block_type.nil?
       if type.is_a?(String)
         @types << type
         @names << name
         # mark what should be picked for this position when dispatching
         @weaving << @names.size()-1
       else
         raise ArgumentError, "Type signature argument must be a String reference to a Puppet Data Type. Got #{type.class}"
       end
     end
 
     # Defines one required block parameter that may appear last. If type and name is missing the
     # default type is "Callable", and the name is "block". If only one
     # parameter is given, then that is the name and the type is "Callable".
     #
     # @api public
     def required_block_param(*type_and_name)
       case type_and_name.size
       when 0
         # the type must be an independent instance since it will be contained in another type
         type = @all_callables.copy
         name = 'block'
       when 1
         # the type must be an independent instance since it will be contained in another type
         type = @all_callables.copy
         name = type_and_name[0]
       when 2
         type_string, name = type_and_name
         type = @type_parser.parse(type_string)
       else
         raise ArgumentError, "block_param accepts max 2 arguments (type, name), got #{type_and_name.size}."
       end
 
       unless Puppet::Pops::Types::TypeCalculator.is_kind_of_callable?(type, false)
         raise ArgumentError, "Expected PCallableType or PVariantType thereof, got #{type.class}"
       end
 
       unless name.is_a?(String) || name.is_a?(Symbol)
         raise ArgumentError, "Expected block_param name to be a String or Symbol, got #{name.class}"
       end
 
       if @block_type.nil?
         @block_type = type
         @block_name = name
-
-        # mark what should be picked for this position when dispatching. This is the size of
-        # the @names array since the block is required to appear last
-        @weaving << @names.size()
       else
-        raise ArgumentError, "Attempt to redefine block"
+        raise ArgumentError, 'Attempt to redefine block'
       end
     end
 
     # Defines one optional block parameter that may appear last. If type or name is missing the
     # defaults are "any callable", and the name is "block". The implementor of the dispatch target
     # must use block = nil when it is optional (or an error is raised when the call is made).
     #
     # @api public
     def optional_block_param(*type_and_name)
       # same as required, only wrap the result in an optional type
       required_block_param(*type_and_name)
       @block_type = Puppet::Pops::Types::TypeFactory.optional(@block_type)
     end
 
-    # Specifies the min and max occurance of arguments (of the specified types)
+    # Specifies the min and max occurrence of arguments (of the specified types)
     # if something other than the exact count from the number of specified
     # types). The max value may be specified as :default if an infinite number of
     # arguments are supported. When max is > than the number of specified
     # types, the last specified type repeats.
     #
     # @api public
     def arg_count(min_occurs, max_occurs)
       @min = min_occurs
       @max = max_occurs
       unless min_occurs.is_a?(Integer) && min_occurs >= 0
         raise ArgumentError, "min arg_count of function parameter must be an Integer >=0, got #{min_occurs.class} '#{min_occurs}'"
       end
-      unless max_occurs == :default || (max_occurs.is_a?(Integer) && max_occurs >= 0)
-        raise ArgumentError, "max arg_count of function parameter must be an Integer >= 0, or :default, got #{max_occurs.class} '#{max_occurs}'"
-      end
-      unless max_occurs == :default || (max_occurs.is_a?(Integer) && max_occurs >= min_occurs)
-        raise ArgumentError, "max arg_count must be :default (infinite) or >= min arg_count, got min: '#{min_occurs}, max: '#{max_occurs}'"
+      if max_occurs == :default
+        @last_captures = true
+      else
+        unless max_occurs.is_a?(Integer) && max_occurs >= min_occurs
+          raise ArgumentError, "max arg_count of function parameter must be :default (infinite) or an Integer >= min arg_count, got min: '#{min_occurs}, max: '#{max_occurs}'"
+        end
       end
     end
 
     # Specifies that the last argument captures the rest.
     #
     # @api public
     def last_captures_rest
       @last_captures = true
     end
 
     private
 
     # @api private
     def dispatch(meth_name, &block)
       # an array of either an index into names/types, or an array with
       # injection information [type, name, injection_name] used when the call
       # is being made to weave injections into the given arguments.
       #
       @types = []
       @names = []
       @weaving = []
       @injections = []
       @min = nil
       @max = nil
       @last_captures = false
       @block_type = nil
       @block_name = nil
       self.instance_eval &block
       callable_t = create_callable(@types, @block_type, @min, @max)
       @dispatcher.add_dispatch(callable_t, meth_name, @names, @block_name, @injections, @weaving, @last_captures)
     end
 
     # Handles creation of a callable type from strings specifications of puppet
     # types and allows the min/max occurs of the given types to be given as one
     # or two integer values at the end.  The given block_type should be
     # Optional[Callable], Callable, or nil.
     #
     # @api private
     def create_callable(types, block_type, from, to)
       mapped_types = types.map do |t|
         @type_parser.parse(t)
       end
 
       if !(from.nil? && to.nil?)
         mapped_types << from
         mapped_types << to
       end
 
       if block_type
         mapped_types << block_type
       end
 
       Puppet::Pops::Types::TypeFactory.callable(*mapped_types)
     end
   end
 
   private
 
   # @note WARNING: This style of creating functions is not public. It is a system
   #   under development that will be used for creating "system" functions.
   #
   # This is a private, internal, system for creating functions. It supports
   # everything that the public function definition system supports as well as a
   # few extra features.
   #
   # Injection Support
   # ===
   # The Function API supports injection of data and services. It is possible to
   # make injection that takes effect when the function is loaded (for services
   # and runtime configuration that does not change depending on how/from where
   # in what context the function is called. It is also possible to inject and
   # weave argument values into a call.
   #
   # Injection of attributes
   # ---
   # Injection of attributes is performed by one of the methods `attr_injected`,
   # and `attr_injected_producer`.  The injected attributes are available via
   # accessor method calls.
   #
   # @example using injected attributes
   #   Puppet::Functions.create_function('test') do
   #     attr_injected String, :larger, 'message_larger'
   #     attr_injected String, :smaller, 'message_smaller'
   #     def test(a, b)
   #       a > b ? larger() : smaller()
   #     end
   #   end
   #
   # @api private
   class InternalFunction < Function
     # @api private
     def self.builder
       @type_parser ||= Puppet::Pops::Types::TypeParser.new
       @all_callables ||= Puppet::Pops::Types::TypeFactory.all_callables
       InternalDispatchBuilder.new(dispatcher, @type_parser, @all_callables)
     end
 
     # Defines class level injected attribute with reader method
     #
     # @api private
     def self.attr_injected(type, attribute_name, injection_name = nil)
       define_method(attribute_name) do
         ivar = :"@#{attribute_name.to_s}"
         unless instance_variable_defined?(ivar)
           injector = Puppet.lookup(:injector)
           instance_variable_set(ivar, injector.lookup(closure_scope, type, injection_name))
         end
         instance_variable_get(ivar)
       end
     end
 
     # Defines class level injected producer attribute with reader method
     #
     # @api private
     def self.attr_injected_producer(type, attribute_name, injection_name = nil)
       define_method(attribute_name) do
         ivar = :"@#{attribute_name.to_s}"
         unless instance_variable_defined?(ivar)
           injector = Puppet.lookup(:injector)
           instance_variable_set(ivar, injector.lookup_producer(closure_scope, type, injection_name))
         end
         instance_variable_get(ivar)
       end
     end
 
     # Allows the implementation of a function to call other functions by name and pass the caller
     # scope. The callable functions are those visible to the same loader that loaded this function
     # (the calling function).
     #
     # @param scope [Puppet::Parser::Scope] The caller scope
     # @param function_name [String] The name of the function
     # @param *args [Object] splat of arguments
     # @return [Object] The result returned by the called function
     #
     # @api public
     def call_function_with_scope(scope, function_name, *args)
       internal_call_function(scope, function_name, args)
     end
   end
 
   # @note WARNING: This style of creating functions is not public. It is a system
   #   under development that will be used for creating "system" functions.
   #
   # Injection and Weaving of parameters
   # ---
   # It is possible to inject and weave parameters into a call. These extra
   # parameters are not part of the parameters passed from the Puppet logic, and
   # they can not be overridden by parameters given as arguments in the call.
   # They are invisible to the Puppet Language.
   #
   # @example using injected parameters
   #   Puppet::Functions.create_function('test') do
   #     dispatch :test do
   #       param 'Scalar', 'a'
   #       param 'Scalar', 'b'
   #       injected_param 'String', 'larger', 'message_larger'
   #       injected_param 'String', 'smaller', 'message_smaller'
   #     end
   #     def test(a, b, larger, smaller)
   #       a > b ? larger : smaller
   #     end
   #   end
   #
   # The function in the example above is called like this:
   #
   #     test(10, 20)
   #
   # Using injected value as default
   # ---
   # Default value assignment is handled by using the regular Ruby mechanism (a
   # value is assigned to the variable).  The dispatch simply indicates that the
   # value is optional. If the default value should be injected, it can be
   # handled different ways depending on what is desired:
   #
   # * by calling the accessor method for an injected Function class attribute.
   #   This is suitable if the value is constant across all instantiations of the
   #   function, and across all calls.
   # * by injecting a parameter into the call
   #   to the left of the parameter, and then assigning that as the default value.
   # * One of the above forms, but using an injected producer instead of a
   #   directly injected value.
   #
   # @example method with injected default values
   #   Puppet::Functions.create_function('test') do
   #     dispatch :test do
   #       injected_param String, 'b_default', 'b_default_value_key'
   #       param 'Scalar', 'a'
   #       param 'Scalar', 'b'
   #     end
   #     def test(b_default, a, b = b_default)
   #       # ...
   #     end
   #   end
   #
   # @api private
   class InternalDispatchBuilder < DispatcherBuilder
     def scope_param()
       @injections << [:scope, 'scope', '', :dispatcher_internal]
       # mark what should be picked for this position when dispatching
       @weaving << [@injections.size()-1]
     end
     # TODO: is param name really needed? Perhaps for error messages? (it is unused now)
     #
     # @api private
     def injected_param(type, name, injection_name = '')
       @injections << [type, name, injection_name]
       # mark what should be picked for this position when dispatching
       @weaving << [@injections.size() -1]
     end
 
     # TODO: is param name really needed? Perhaps for error messages? (it is unused now)
     #
     # @api private
     def injected_producer_param(type, name, injection_name = '')
       @injections << [type, name, injection_name, :producer]
       # mark what should be picked for this position when dispatching
       @weaving << [@injections.size()-1]
     end
   end
 end
diff --git a/lib/puppet/functions/assert_type.rb b/lib/puppet/functions/assert_type.rb
index 7165dec70..f51cddce5 100644
--- a/lib/puppet/functions/assert_type.rb
+++ b/lib/puppet/functions/assert_type.rb
@@ -1,59 +1,59 @@
 # Returns the given value if it is an instance of the given type, and raises an error otherwise.
 # Optionally, if a block is given (accepting two parameters), it will be called instead of raising
 # an error. This to enable giving the user richer feedback, or to supply a default value.
 #
 # @example how to assert type
 #   # assert that `$b` is a non empty `String` and assign to `$a`
 #   $a = assert_type(String[1], $b)
 #
 # @example using custom error message
 #   $a = assert_type(String[1], $b) |$expected, $actual| { fail("The name cannot be empty") }
 #
 # @example using a warning and a default
 #   $a = assert_type(String[1], $b) |$expected, $actual| { warning("Name is empty, using default") 'anonymous' }
 #
 # See the documentation for "The Puppet Type System" for more information about types.
 #
 Puppet::Functions.create_function(:assert_type) do
   dispatch :assert_type do
     param 'Type', 'type'
     param 'Any', 'value'
     optional_block_param 'Callable[Type, Type]', 'block'
   end
 
   dispatch :assert_type_s do
     param 'String', 'type_string'
     param 'Any', 'value'
     optional_block_param 'Callable[Type, Type]', 'block'
   end
 
   # @param type [Type] the type the value must be an instance of
   # @param value [Object] the value to assert
   #
-  def assert_type(type, value, block=nil)
+  def assert_type(type, value)
     unless Puppet::Pops::Types::TypeCalculator.instance?(type,value)
       inferred_type = Puppet::Pops::Types::TypeCalculator.infer(value)
-      if block
+      if block_given?
         # Give the inferred type to allow richer comparisson in the given block (if generalized
         # information is lost).
         #
-        value = block.call(nil, type, inferred_type)
+        value = yield(type, inferred_type)
       else
         # Do not give all the details - i.e. format as Integer, instead of Integer[n, n] for exact value, which
         # is just confusing. (OTOH: may need to revisit, or provide a better "type diff" output.
         #
         actual = Puppet::Pops::Types::TypeCalculator.generalize!(inferred_type)
         raise Puppet::ParseError, "assert_type(): Expected type #{type} does not match actual: #{actual}"
       end
     end
     value
   end
 
   # @param type_string [String] the type the value must be an instance of given in String form
   # @param value [Object] the value to assert
   #
-  def assert_type_s(type_string, value)
+  def assert_type_s(type_string, value, &proc)
     t = Puppet::Pops::Types::TypeParser.new.parse(type_string)
-    assert_type(t, value)
+    block_given? ? assert_type(t, value, &proc) : assert_type(t, value)
   end
 end
diff --git a/lib/puppet/functions/each.rb b/lib/puppet/functions/each.rb
index dbdf1b614..a9c9caf7b 100644
--- a/lib/puppet/functions/each.rb
+++ b/lib/puppet/functions/each.rb
@@ -1,111 +1,111 @@
 #  Applies a parameterized block to each element in a sequence of selected entries from the first
 #  argument and returns the first argument.
 #
 # This function takes two mandatory arguments: the first should be an Array or a Hash or something that is
 # of enumerable type (integer, Integer range, or String), and the second
 # a parameterized block as produced by the puppet syntax:
 #
 #       $a.each |$x| { ... }
 #       each($a) |$x| { ... }
 #
 # When the first argument is an Array (or of enumerable type other than Hash), the parameterized block
 # should define one or two block parameters.
 # For each application of the block, the next element from the array is selected, and it is passed to
 # the block if the block has one parameter. If the block has two parameters, the first is the elements
 # index, and the second the value. The index starts from 0.
 #
 #       $a.each |$index, $value| { ... }
 #       each($a) |$index, $value| { ... }
 #
 # When the first argument is a Hash, the parameterized block should define one or two parameters.
 # When one parameter is defined, the iteration is performed with each entry as an array of `[key, value]`,
 # and when two parameters are defined the iteration is performed with key and value.
 #
 #       $a.each |$entry|       { ..."key ${$entry[0]}, value ${$entry[1]}" }
 #       $a.each |$key, $value| { ..."key ${key}, value ${value}" }
 #
 # @example using each
 #
 #       [1,2,3].each |$val| { ... }                       # 1, 2, 3
 #       [5,6,7].each |$index, $val| { ... }               # (0, 5), (1, 6), (2, 7)
 #       {a=>1, b=>2, c=>3}].each |$val| { ... }           # ['a', 1], ['b', 2], ['c', 3]
 #       {a=>1, b=>2, c=>3}.each |$key, $val| { ... }      # ('a', 1), ('b', 2), ('c', 3)
 #       Integer[ 10, 20 ].each |$index, $value| { ... }   # (0, 10), (1, 11) ...
 #       "hello".each |$char| { ... }                      # 'h', 'e', 'l', 'l', 'o'
 #       3.each |$number| { ... }                          # 0, 1, 2
 #
 # @since 3.2 for Array and Hash
 # @since 3.5 for other enumerables
 # @note requires `parser = future`
 #
 Puppet::Functions.create_function(:each) do
   dispatch :foreach_Hash_2 do
     param 'Hash[Any, Any]', :hash
     required_block_param 'Callable[2,2]', :block
   end
 
   dispatch :foreach_Hash_1 do
     param 'Hash[Any, Any]', :hash
     required_block_param 'Callable[1,1]', :block
   end
 
   dispatch :foreach_Enumerable_2 do
     param 'Any', :enumerable
     required_block_param 'Callable[2,2]', :block
   end
 
   dispatch :foreach_Enumerable_1 do
     param 'Any', :enumerable
     required_block_param 'Callable[1,1]', :block
   end
 
-  def foreach_Hash_1(hash, pblock)
+  def foreach_Hash_1(hash)
     enumerator = hash.each_pair
     hash.size.times do
-      pblock.call(enumerator.next)
+      yield(enumerator.next)
     end
     # produces the receiver
     hash
   end
 
-  def foreach_Hash_2(hash, pblock)
+  def foreach_Hash_2(hash)
     enumerator = hash.each_pair
     hash.size.times do
-      pblock.call(*enumerator.next)
+      yield(*enumerator.next)
     end
     # produces the receiver
     hash
   end
 
-  def foreach_Enumerable_1(enumerable, pblock)
+  def foreach_Enumerable_1(enumerable)
     enum = asserted_enumerable(enumerable)
       begin
-        loop { pblock.call(enum.next) }
+        loop { yield(enum.next) }
       rescue StopIteration
       end
     # produces the receiver
     enumerable
   end
 
-  def foreach_Enumerable_2(enumerable, pblock)
+  def foreach_Enumerable_2(enumerable)
     enum = asserted_enumerable(enumerable)
     index = 0
     begin
       loop do
-        pblock.call(index, enum.next)
+        yield(index, enum.next)
         index += 1
       end
     rescue StopIteration
     end
     # produces the receiver
     enumerable
   end
 
   def asserted_enumerable(obj)
     unless enum = Puppet::Pops::Types::Enumeration.enumerator(obj)
       raise ArgumentError, ("#{self.class.name}(): wrong argument type (#{obj.class}; must be something enumerable.")
     end
     enum
   end
 
 end
diff --git a/lib/puppet/functions/filter.rb b/lib/puppet/functions/filter.rb
index c88909d32..0edcfbbad 100644
--- a/lib/puppet/functions/filter.rb
+++ b/lib/puppet/functions/filter.rb
@@ -1,113 +1,113 @@
 # Applies a parameterized block to each element in a sequence of entries from the first
 # argument and returns an array or hash (same type as left operand for array/hash, and array for
 # other enumerable types) with the entries for which the block evaluates to `true`.
 #
 # This function takes two mandatory arguments: the first should be an Array, a Hash, or an
 # Enumerable object (integer, Integer range, or String),
 # and the second a parameterized block as produced by the puppet syntax:
 #
 #       $a.filter |$x| { ... }
 #       filter($a) |$x| { ... }
 #
 # When the first argument is something other than a Hash, the block is called with each entry in turn.
 # When the first argument is a Hash the entry is an array with `[key, value]`.
 #
 # @example Using filter with one parameter
 #
 #       # selects all that end with berry
 #       $a = ["raspberry", "blueberry", "orange"]
 #       $a.filter |$x| { $x =~ /berry$/ }          # rasberry, blueberry
 #
 # If the block defines two parameters, they will be set to `index, value` (with index starting at 0) for all
 # enumerables except Hash, and to `key, value` for a Hash.
 #
 # @example Using filter with two parameters
 #
 #      # selects all that end with 'berry' at an even numbered index
 #      $a = ["raspberry", "blueberry", "orange"]
 #      $a.filter |$index, $x| { $index % 2 == 0 and $x =~ /berry$/ } # raspberry
 #
 #      # selects all that end with 'berry' and value >= 1
 #      $a = {"raspberry"=>0, "blueberry"=>1, "orange"=>1}
 #      $a.filter |$key, $x| { $x =~ /berry$/ and $x >= 1 } # blueberry
 #
 # @since 3.4 for Array and Hash
 # @since 3.5 for other enumerables
 # @note requires `parser = future`
 #
 Puppet::Functions.create_function(:filter) do
   dispatch :filter_Hash_2 do
     param 'Hash[Any, Any]', :hash
     required_block_param 'Callable[2,2]', :block
   end
 
   dispatch :filter_Hash_1 do
     param 'Hash[Any, Any]', :hash
     required_block_param 'Callable[1,1]', :block
   end
 
   dispatch :filter_Enumerable_2 do
     param 'Any', :enumerable
     required_block_param 'Callable[2,2]', :block
   end
 
   dispatch :filter_Enumerable_1 do
     param 'Any', :enumerable
     required_block_param 'Callable[1,1]', :block
   end
 
-  def filter_Hash_1(hash, pblock)
-    result = hash.select {|x, y| pblock.call([x, y]) }
+  def filter_Hash_1(hash)
+    result = hash.select {|x, y| yield([x, y]) }
     # Ruby 1.8.7 returns Array
     result = Hash[result] unless result.is_a? Hash
     result
   end
 
-  def filter_Hash_2(hash, pblock)
-    result = hash.select {|x, y| pblock.call(x, y) }
+  def filter_Hash_2(hash)
+    result = hash.select {|x, y| yield(x, y) }
     # Ruby 1.8.7 returns Array
     result = Hash[result] unless result.is_a? Hash
     result
   end
 
-  def filter_Enumerable_1(enumerable, pblock)
+  def filter_Enumerable_1(enumerable)
     result = []
     index = 0
     enum = asserted_enumerable(enumerable)
     begin
       loop do
         it = enum.next
-        if pblock.call(it) == true
+        if yield(it) == true
           result << it
         end
       end
     rescue StopIteration
     end
     result
   end
 
-  def filter_Enumerable_2(enumerable, pblock)
+  def filter_Enumerable_2(enumerable)
     result = []
     index = 0
     enum = asserted_enumerable(enumerable)
     begin
       loop do
         it = enum.next
-        if pblock.call(index, it) == true
+        if yield(index, it) == true
           result << it
         end
         index += 1
       end
     rescue StopIteration
     end
     result
   end
 
   def asserted_enumerable(obj)
     unless enum = Puppet::Pops::Types::Enumeration.enumerator(obj)
       raise ArgumentError, ("#{self.class.name}(): wrong argument type (#{obj.class}; must be something enumerable.")
     end
     enum
   end
 
 end
diff --git a/lib/puppet/functions/map.rb b/lib/puppet/functions/map.rb
index c0f049aec..41e79a382 100644
--- a/lib/puppet/functions/map.rb
+++ b/lib/puppet/functions/map.rb
@@ -1,97 +1,97 @@
 # Applies a parameterized block to each element in a sequence of entries from the first
 # argument and returns an array with the result of each invocation of the parameterized block.
 #
 # This function takes two mandatory arguments: the first should be an Array, Hash, or of Enumerable type
 # (integer, Integer range, or String), and the second a parameterized block as produced by the puppet syntax:
 #
 #       $a.map |$x| { ... }
 #       map($a) |$x| { ... }
 #
 # When the first argument `$a` is an Array or of enumerable type, the block is called with each entry in turn.
 # When the first argument is a hash the entry is an array with `[key, value]`.
 #
 # @example Using map with two arguments
 #
 #      # Turns hash into array of values
 #      $a.map |$x|{ $x[1] }
 #
 #      # Turns hash into array of keys
 #      $a.map |$x| { $x[0] }
 #
 # When using a block with 2 parameters, the element's index (starting from 0) for an array, and the key for a hash
 # is given to the block's first parameter, and the value is given to the block's second parameter.args.
 #
 # @example Using map with two arguments
 #
 #      # Turns hash into array of values
 #      $a.map |$key,$val|{ $val }
 #
 #      # Turns hash into array of keys
 #      $a.map |$key,$val|{ $key }
 #
 # @since 3.4 for Array and Hash
 # @since 3.5 for other enumerables, and support for blocks with 2 parameters
 # @note requires `parser = future`
 #
 Puppet::Functions.create_function(:map) do
   dispatch :map_Hash_2 do
     param 'Hash[Any, Any]', :hash
     required_block_param 'Callable[2,2]', :block
   end
 
   dispatch :map_Hash_1 do
     param 'Hash[Any, Any]', :hash
     required_block_param 'Callable[1,1]', :block
   end
 
   dispatch :map_Enumerable_2 do
     param 'Any', :enumerable
     required_block_param 'Callable[2,2]', :block
   end
 
   dispatch :map_Enumerable_1 do
     param 'Any', :enumerable
     required_block_param 'Callable[1,1]', :block
   end
 
-  def map_Hash_1(hash, pblock)
-    hash.map {|x, y| pblock.call([x, y]) }
+  def map_Hash_1(hash)
+    hash.map {|x, y| yield([x, y]) }
   end
 
-  def map_Hash_2(hash, pblock)
-      hash.map {|x, y| pblock.call(x, y) }
+  def map_Hash_2(hash)
+      hash.map {|x, y| yield(x, y) }
   end
 
-  def map_Enumerable_1(enumerable, pblock)
+  def map_Enumerable_1(enumerable)
     result = []
     index = 0
     enum = asserted_enumerable(enumerable)
     begin
-      loop { result << pblock.call(enum.next) }
+      loop { result << yield(enum.next) }
     rescue StopIteration
     end
     result
   end
 
-  def map_Enumerable_2(enumerable, pblock)
+  def map_Enumerable_2(enumerable)
     result = []
     index = 0
     enum = asserted_enumerable(enumerable)
     begin
       loop do
-        result << pblock.call(index, enum.next)
+        result << yield(index, enum.next)
         index = index +1
       end
     rescue StopIteration
     end
     result
   end
 
   def asserted_enumerable(obj)
     unless enum = Puppet::Pops::Types::Enumeration.enumerator(obj)
       raise ArgumentError, ("#{self.class.name}(): wrong argument type (#{obj.class}; must be something enumerable.")
     end
     enum
   end
 
 end
diff --git a/lib/puppet/functions/reduce.rb b/lib/puppet/functions/reduce.rb
index f5de76b4b..ef3fa30ac 100644
--- a/lib/puppet/functions/reduce.rb
+++ b/lib/puppet/functions/reduce.rb
@@ -1,94 +1,94 @@
 # Applies a parameterized block to each element in a sequence of entries from the first
 # argument (_the enumerable_) and returns the last result of the invocation of the parameterized block.
 #
 # This function takes two mandatory arguments: the first should be an Array, Hash, or something of
 # enumerable type, and the last a parameterized block as produced by the puppet syntax:
 #
 #       $a.reduce |$memo, $x| { ... }
 #       reduce($a) |$memo, $x| { ... }
 #
 # When the first argument is an Array or someting of an enumerable type, the block is called with each entry in turn.
 # When the first argument is a hash each entry is converted to an array with `[key, value]` before being
 # fed to the block. An optional 'start memo' value may be supplied as an argument between the array/hash
 # and mandatory block.
 #
 #       $a.reduce(start) |$memo, $x| { ... }
 #       reduce($a, start) |$memo, $x| { ... }
 #
 # If no 'start memo' is given, the first invocation of the parameterized block will be given the first and second
 # elements of the enumeration, and if the enumerable has fewer than 2 elements, the first
 # element is produced as the result of the reduction without invocation of the block.
 #
 # On each subsequent invocation, the produced value of the invoked parameterized block is given as the memo in the
 # next invocation.
 #
 # @example Using reduce
 #
 #       # Reduce an array
 #       $a = [1,2,3]
 #       $a.reduce |$memo, $entry| { $memo + $entry }
 #       #=> 6
 #
 #       # Reduce hash values
 #       $a = {a => 1, b => 2, c => 3}
 #       $a.reduce |$memo, $entry| { [sum, $memo[1]+$entry[1]] }
 #       #=> [sum, 6]
 #
 #       # reverse a string
 #       "abc".reduce |$memo, $char| { "$char$memo" }
 #       #=>"cbe"
 #
 # It is possible to provide a starting 'memo' as an argument.
 #
 # @example Using reduce with given start 'memo'
 #
 #       # Reduce an array
 #       $a = [1,2,3]
 #       $a.reduce(4) |$memo, $entry| { $memo + $entry }
 #       #=> 10
 #
 #       # Reduce hash values
 #       $a = {a => 1, b => 2, c => 3}
 #       $a.reduce([na, 4]) |$memo, $entry| { [sum, $memo[1]+$entry[1]] }
 #       #=> [sum, 10]
 #
 # @example Using reduce with an Integer range
 #
 #       Integer[1,4].reduce |$memo, $x| { $memo + $x }
 #       #=> 10
 #
 # @since 3.2 for Array and Hash
 # @since 3.5 for additional enumerable types
 # @note requires `parser = future`.
 #
 Puppet::Functions.create_function(:reduce) do
 
   dispatch :reduce_without_memo do
     param 'Any', :enumerable
     required_block_param 'Callable[2,2]', :block
   end
 
   dispatch :reduce_with_memo do
     param 'Any', :enumerable
     param 'Any', :memo
     required_block_param 'Callable[2,2]', :block
   end
 
-  def reduce_without_memo(enumerable, pblock)
+  def reduce_without_memo(enumerable)
     enum = asserted_enumerable(enumerable)
-    enum.reduce {|memo, x| pblock.call(memo, x) }
+    enum.reduce {|memo, x| yield(memo, x) }
   end
 
-  def reduce_with_memo(enumerable, given_memo, pblock)
+  def reduce_with_memo(enumerable, given_memo)
     enum = asserted_enumerable(enumerable)
-    enum.reduce(given_memo) {|memo, x| pblock.call(memo, x) }
+    enum.reduce(given_memo) {|memo, x| yield(memo, x) }
   end
 
   def asserted_enumerable(obj)
     unless enum = Puppet::Pops::Types::Enumeration.enumerator(obj)
       raise ArgumentError, ("#{self.class.name}(): wrong argument type (#{obj.class}; must be something enumerable.")
     end
     enum
   end
 
 end
diff --git a/lib/puppet/functions/scanf.rb b/lib/puppet/functions/scanf.rb
index 13e4a51a7..d2bd4edf8 100644
--- a/lib/puppet/functions/scanf.rb
+++ b/lib/puppet/functions/scanf.rb
@@ -1,46 +1,46 @@
 # Scans a string and returns an array of one or more converted values as directed by a given format string.args
 # See the documenation of Ruby's String::scanf method for details about the supported formats (which
 # are similar but not identical to the formats used in Puppet's `sprintf` function.
 #
 # This function takes two mandatory arguments: the first is the String to convert, and the second
 # the format String. A parameterized block may optionally be given, which is called with the result
 # that is produced by scanf if no block is present, the result of the block is then returned by
 # the function.
 #
 # The result of the scan is an Array, with each sucessfully scanned and transformed value.args The scanning
 # stops if a scan is unsuccesful and the scanned result up to that point is returned. If there was no
 # succesful scan at all, the result is an empty Array. The optional code block is typically used to
 # assert that the scan was succesful, and either produce the same input, or perform unwrapping of
 # the result
 #
 # @example scanning an integer in string form (result is an array with
 #   integer, or empty if  unsuccessful)
 #    "42".scanf("%i")
 #
 # @example scanning and processing resulting array to assert result and unwrap
 #
 #     "42".scanf("%i") |$x| {
 #       unless $x[0] =~ Integer {
 #         fail "Expected a well formed integer value, got '$x[0]'"
 #       }
 #       $x[0]
 #     }
 #
 # @since 3.7.4
 Puppet::Functions.create_function(:scanf) do
   require 'scanf'
 
   dispatch :scanf do
     param 'String', 'data'
     param 'String', 'format'
     optional_block_param
   end
 
-  def scanf(data, format, block=nil)
+  def scanf(data, format)
     result = data.scanf(format)
-    if !block.nil?
-      result = block.call(result)
+    if block_given?
+      result = yield(result)
     end
     result
   end
 end
diff --git a/lib/puppet/functions/slice.rb b/lib/puppet/functions/slice.rb
index 6c83b5637..93202e2a6 100644
--- a/lib/puppet/functions/slice.rb
+++ b/lib/puppet/functions/slice.rb
@@ -1,126 +1,127 @@
 # Applies a parameterized block to each _slice_ of elements in a sequence of selected entries from the first
 # argument and returns the first argument, or if no block is given returns a new array with a concatenation of
 # the slices.
 #
 # This function takes two mandatory arguments: the first, `$a`, should be an Array, Hash, or something of
 # enumerable type (integer, Integer range, or String), and the second, `$n`, the number of elements to include
 # in each slice. The optional third argument should be a a parameterized block as produced by the puppet syntax:
 #
 #     $a.slice($n) |$x| { ... }
 #     slice($a) |$x| { ... }
 #
 # The parameterized block should have either one parameter (receiving an array with the slice), or the same number
 # of parameters as specified by the slice size (each parameter receiving its part of the slice).
 # In case there are fewer remaining elements than the slice size for the last slice it will contain the remaining
 # elements. When the block has multiple parameters, excess parameters are set to undef for an array or
 # enumerable type, and to empty arrays for a Hash.
 #
 #     $a.slice(2) |$first, $second| { ... }
 #
 # When the first argument is a Hash, each `key,value` entry is counted as one, e.g, a slice size of 2 will produce
 # an array of two arrays with key, and value.
 #
 # @example Using slice with Hash
 #
 #     $a.slice(2) |$entry|          { notice "first ${$entry[0]}, second ${$entry[1]}" }
 #     $a.slice(2) |$first, $second| { notice "first ${first}, second ${second}" }
 #
 # When called without a block, the function produces a concatenated result of the slices.
 #
 # @example Using slice without a block
 #
 #     slice([1,2,3,4,5,6], 2) # produces [[1,2], [3,4], [5,6]]
 #     slice(Integer[1,6], 2)  # produces [[1,2], [3,4], [5,6]]
 #     slice(4,2)              # produces [[0,1], [2,3]]
 #     slice('hello',2)        # produces [[h, e], [l, l], [o]]
 #
 # @since 3.2 for Array and Hash
 # @since 3.5 for additional enumerable types
 # @note requires `parser = future`.
 #
 Puppet::Functions.create_function(:slice) do
   dispatch :slice_Hash do
     param 'Hash[Any, Any]', :hash
     param 'Integer[1, default]', :slize_size
     optional_block_param
   end
 
   dispatch :slice_Enumerable do
     param 'Any', :enumerable
     param 'Integer[1, default]', :slize_size
     optional_block_param
   end
 
-  def slice_Hash(hash, slice_size, pblock = nil)
-    result = slice_Common(hash, slice_size, [], pblock)
-    pblock ? hash : result
+  def slice_Hash(hash, slice_size, &pblock)
+    result = slice_Common(hash, slice_size, [], block_given? ? pblock : nil)
+    block_given? ? hash : result
   end
 
-  def slice_Enumerable(enumerable, slice_size, pblock = nil)
+  def slice_Enumerable(enumerable, slice_size, &pblock)
     enum = asserted_enumerable(enumerable)
-    result = slice_Common(enum, slice_size, nil, pblock)
-    pblock ? enumerable : result
+    result = slice_Common(enum, slice_size, nil, block_given? ? pblock : nil)
+    block_given? ? enumerable : result
   end
 
   def slice_Common(o, slice_size, filler, pblock)
     serving_size = asserted_slice_serving_size(pblock, slice_size)
 
     enumerator = o.each_slice(slice_size)
     result = []
     if serving_size == 1
       begin
         if pblock
           loop do
             pblock.call(enumerator.next)
           end
         else
           loop do
             result << enumerator.next
           end
         end
       rescue StopIteration
       end
     else
       begin
         loop do
           a = enumerator.next
           if a.size < serving_size
             a = a.dup.fill(filler, a.length...serving_size)
           end
           pblock.call(*a)
         end
       rescue StopIteration
       end
     end
     if pblock
       o
     else
       result
     end
   end
 
   def asserted_slice_serving_size(pblock, slice_size)
     if pblock
-      serving_size = pblock.last_captures_rest? ? slice_size : pblock.parameter_count
+      arity = pblock.arity
+      serving_size = arity < 0 ? slice_size : arity
     else
       serving_size = 1
     end
     if serving_size == 0
       raise ArgumentError, "slice(): block must define at least one parameter. Block has 0."
     end
     unless serving_size == 1 || serving_size == slice_size
       raise ArgumentError, "slice(): block must define one parameter, or " +
         "the same number of parameters as the given size of the slice (#{slice_size}). Block has #{serving_size}; "+
       pblock.parameter_names.join(', ')
     end
     serving_size
   end
 
   def asserted_enumerable(obj)
     unless enum = Puppet::Pops::Types::Enumeration.enumerator(obj)
       raise ArgumentError, ("#{self.class.name}(): wrong argument type (#{obj.class}; must be something enumerable.")
     end
     enum
   end
 
 end
diff --git a/lib/puppet/functions/with.rb b/lib/puppet/functions/with.rb
index 9971fa6b3..cde4056d8 100644
--- a/lib/puppet/functions/with.rb
+++ b/lib/puppet/functions/with.rb
@@ -1,23 +1,23 @@
 # Call a lambda with the given arguments. Since the parameters of the lambda
 # are local to the lambda's scope, this can be used to create private sections
 # of logic in a class so that the variables are not visible outside of the
 # class.
 #
 # @example Using with
 #
 #     # notices the array [1, 2, 'foo']
 #     with(1, 2, 'foo') |$x, $y, $z| { notice [$x, $y, $z] }
 #
 # @since 3.7.0
 #
 Puppet::Functions.create_function(:with) do
   dispatch :with do
     param 'Any', 'arg'
     arg_count(0, :default)
     required_block_param
   end
 
   def with(*args)
-    args[-1].call(*args[0..-2])
+    yield(*args)
   end
 end
diff --git a/lib/puppet/pops.rb b/lib/puppet/pops.rb
index 41ce5b5c5..692a4e025 100644
--- a/lib/puppet/pops.rb
+++ b/lib/puppet/pops.rb
@@ -1,126 +1,127 @@
 module Puppet
   # The Pops language system. This includes the parser, evaluator, AST model, and
   # Binder.
   #
   # @todo Explain how a user should use this to parse and evaluate the puppet
   #   language.
   #
   # @note Warning: Pops is still considered experimental, as such the API may
   #   change at any time.
   #
   # @api public
   module Pops
     require 'puppet/pops/patterns'
     require 'puppet/pops/utils'
 
     require 'puppet/pops/adaptable'
     require 'puppet/pops/adapters'
 
     require 'puppet/pops/visitable'
     require 'puppet/pops/visitor'
 
     require 'puppet/pops/containment'
 
     require 'puppet/pops/issues'
     require 'puppet/pops/semantic_error'
     require 'puppet/pops/label_provider'
     require 'puppet/pops/validation'
     require 'puppet/pops/issue_reporter'
 
     require 'puppet/pops/model/model'
 
     # (the Types module initializes itself)
     require 'puppet/pops/types/types'
     require 'puppet/pops/types/type_calculator'
     require 'puppet/pops/types/type_factory'
     require 'puppet/pops/types/type_parser'
     require 'puppet/pops/types/class_loader'
     require 'puppet/pops/types/enumeration'
 
 
     module Model
       require 'puppet/pops/model/tree_dumper'
       require 'puppet/pops/model/ast_transformer'
       require 'puppet/pops/model/ast_tree_dumper'
       require 'puppet/pops/model/factory'
       require 'puppet/pops/model/model_tree_dumper'
       require 'puppet/pops/model/model_label_provider'
     end
 
     module Binder
       module SchemeHandler
         # the handlers are auto loaded via bindings
       end
       module Producers
         require 'puppet/pops/binder/producers'
       end
 
       require 'puppet/pops/binder/binder'
       require 'puppet/pops/binder/bindings_model'
       require 'puppet/pops/binder/binder_issues'
       require 'puppet/pops/binder/bindings_checker'
       require 'puppet/pops/binder/bindings_factory'
       require 'puppet/pops/binder/bindings_label_provider'
       require 'puppet/pops/binder/bindings_validator_factory'
       require 'puppet/pops/binder/injector_entry'
       require 'puppet/pops/binder/key_factory'
       require 'puppet/pops/binder/injector'
       require 'puppet/pops/binder/bindings_composer'
       require 'puppet/pops/binder/bindings_model_dumper'
       require 'puppet/pops/binder/system_bindings'
       require 'puppet/pops/binder/bindings_loader'
       require 'puppet/pops/binder/lookup'
 
       module Config
         require 'puppet/pops/binder/config/binder_config'
         require 'puppet/pops/binder/config/binder_config_checker'
         require 'puppet/pops/binder/config/issues'
         require 'puppet/pops/binder/config/diagnostic_producer'
       end
     end
 
     module Parser
       require 'puppet/pops/parser/eparser'
       require 'puppet/pops/parser/parser_support'
       require 'puppet/pops/parser/locator'
       require 'puppet/pops/parser/locatable'
       require 'puppet/pops/parser/lexer2'
       require 'puppet/pops/parser/evaluating_parser'
       require 'puppet/pops/parser/epp_parser'
     end
 
     module Validation
       require 'puppet/pops/validation/checker4_0'
       require 'puppet/pops/validation/validator_factory_4_0'
     end
 
     module Evaluator
       require 'puppet/pops/evaluator/callable_signature'
       require 'puppet/pops/evaluator/runtime3_converter'
       require 'puppet/pops/evaluator/runtime3_support'
       require 'puppet/pops/evaluator/evaluator_impl'
       require 'puppet/pops/evaluator/epp_evaluator'
       require 'puppet/pops/evaluator/callable_mismatch_describer'
       require 'puppet/pops/evaluator/collector_transformer'
+      require 'puppet/pops/evaluator/puppet_proc'
       module Collectors
         require 'puppet/pops/evaluator/collectors/abstract_collector'
         require 'puppet/pops/evaluator/collectors/fixed_set_collector'
         require 'puppet/pops/evaluator/collectors/catalog_collector'
         require 'puppet/pops/evaluator/collectors/exported_collector'
       end
     end
 
     # Subsystem for puppet functions defined in ruby.
     #
     # @api public
     module Functions
       require 'puppet/pops/functions/function'
       require 'puppet/pops/functions/dispatch'
       require 'puppet/pops/functions/dispatcher'
     end
   end
 
   require 'puppet/parser/ast/pops_bridge'
   require 'puppet/bindings'
   require 'puppet/functions'
 end
diff --git a/lib/puppet/pops/evaluator/evaluator_impl.rb b/lib/puppet/pops/evaluator/evaluator_impl.rb
index ae4b21edb..c24101c1e 100644
--- a/lib/puppet/pops/evaluator/evaluator_impl.rb
+++ b/lib/puppet/pops/evaluator/evaluator_impl.rb
@@ -1,1098 +1,1162 @@
 require 'rgen/ecore/ecore'
 require 'puppet/pops/evaluator/compare_operator'
 require 'puppet/pops/evaluator/relationship_operator'
 require 'puppet/pops/evaluator/access_operator'
 require 'puppet/pops/evaluator/closure'
 require 'puppet/pops/evaluator/external_syntax_support'
 
 # This implementation of {Puppet::Pops::Evaluator} performs evaluation using the puppet 3.x runtime system
 # in a manner largely compatible with Puppet 3.x, but adds new features and introduces constraints.
 #
 # The evaluation uses _polymorphic dispatch_ which works by dispatching to the first found method named after
 # the class or one of its super-classes. The EvaluatorImpl itself mainly deals with evaluation (it currently
 # also handles assignment), and it uses a delegation pattern to more specialized handlers of some operators
 # that in turn use polymorphic dispatch; this to not clutter EvaluatorImpl with too much responsibility).
 #
 # Since a pattern is used, only the main entry points are fully documented. The parameters _o_ and _scope_ are
 # the same in all the polymorphic methods, (the type of the parameter _o_ is reflected in the method's name;
 # either the actual class, or one of its super classes). The _scope_ parameter is always the scope in which
 # the evaluation takes place. If nothing else is mentioned, the return is always the result of evaluation.
 #
 # See {Puppet::Pops::Visitable} and {Puppet::Pops::Visitor} for more information about
 # polymorphic calling.
 #
 class Puppet::Pops::Evaluator::EvaluatorImpl
   include Puppet::Pops::Utils
 
   # Provides access to the Puppet 3.x runtime (scope, etc.)
   # This separation has been made to make it easier to later migrate the evaluator to an improved runtime.
   #
   include Puppet::Pops::Evaluator::Runtime3Support
   include Puppet::Pops::Evaluator::ExternalSyntaxSupport
 
   # This constant is not defined as Float::INFINITY in Ruby 1.8.7 (but is available in later version
   # Refactor when support is dropped for Ruby 1.8.7.
   #
   INFINITY = 1.0 / 0.0
   EMPTY_STRING = ''.freeze
   COMMA_SEPARATOR = ', '.freeze
 
   # Reference to Issues name space makes it easier to refer to issues
   # (Issues are shared with the validator).
   #
   Issues = Puppet::Pops::Issues
 
   def initialize
     @@eval_visitor     ||= Puppet::Pops::Visitor.new(self, "eval", 1, 1)
     @@lvalue_visitor   ||= Puppet::Pops::Visitor.new(self, "lvalue", 1, 1)
     @@assign_visitor   ||= Puppet::Pops::Visitor.new(self, "assign", 3, 3)
     @@string_visitor   ||= Puppet::Pops::Visitor.new(self, "string", 1, 1)
 
     @@type_calculator  ||= Puppet::Pops::Types::TypeCalculator.new()
     @@type_parser      ||= Puppet::Pops::Types::TypeParser.new()
 
     @@compare_operator     ||= Puppet::Pops::Evaluator::CompareOperator.new()
     @@relationship_operator ||= Puppet::Pops::Evaluator::RelationshipOperator.new()
   end
 
   # @api private
   def type_calculator
     @@type_calculator
   end
 
   # Evaluates the given _target_ object in the given scope.
   #
   # @overload evaluate(target, scope)
   # @param target [Object] evaluation target - see methods on the pattern assign_TYPE for actual supported types.
   # @param scope [Object] the runtime specific scope class where evaluation should take place
   # @return [Object] the result of the evaluation
   #
   # @api public
   #
   def evaluate(target, scope)
     begin
       @@eval_visitor.visit_this_1(self, target, scope)
 
     rescue Puppet::Pops::SemanticError => e
       # a raised issue may not know the semantic target
       fail(e.issue, e.semantic || target, e.options, e)
 
     rescue StandardError => e
       if e.is_a? Puppet::ParseError
         # ParseError's are supposed to be fully configured with location information
         raise e
       end
       fail(Issues::RUNTIME_ERROR, target, {:detail => e.message}, e)
     end
   end
 
   # Assigns the given _value_ to the given _target_. The additional argument _o_ is the instruction that
   # produced the target/value tuple and it is used to set the origin of the result.
   #
   # @param target [Object] assignment target - see methods on the pattern assign_TYPE for actual supported types.
   # @param value [Object] the value to assign to `target`
   # @param o [Puppet::Pops::Model::PopsObject] originating instruction
   # @param scope [Object] the runtime specific scope where evaluation should take place
   #
   # @api private
   #
   def assign(target, value, o, scope)
     @@assign_visitor.visit_this_3(self, target, value, o, scope)
   end
 
   # Computes a value that can be used as the LHS in an assignment.
   # @param o [Object] the expression to evaluate as a left (assignable) entity
   # @param scope [Object] the runtime specific scope where evaluation should take place
   #
   # @api private
   #
   def lvalue(o, scope)
     @@lvalue_visitor.visit_this_1(self, o, scope)
   end
 
   # Produces a String representation of the given object _o_ as used in interpolation.
   # @param o [Object] the expression of which a string representation is wanted
   # @param scope [Object] the runtime specific scope where evaluation should take place
   #
   # @api public
   #
   def string(o, scope)
     @@string_visitor.visit_this_1(self, o, scope)
   end
 
   # Evaluate a BlockExpression in a new scope with variables bound to the
   # given values.
   #
   # @param scope [Puppet::Parser::Scope] the parent scope
   # @param variable_bindings [Hash{String => Object}] the variable names and values to bind (names are keys, bound values are values)
   # @param block [Puppet::Pops::Model::BlockExpression] the sequence of expressions to evaluate in the new scope
   #
   # @api private
   #
   def evaluate_block_with_bindings(scope, variable_bindings, block_expr)
     with_guarded_scope(scope) do
       # change to create local scope_from - cannot give it file and line -
       # that is the place of the call, not "here"
       create_local_scope_from(variable_bindings, scope)
       evaluate(block_expr, scope)
     end
   end
 
   protected
 
   def lvalue_VariableExpression(o, scope)
     # evaluate the name
     evaluate(o.expr, scope)
   end
 
   # Catches all illegal lvalues
   #
   def lvalue_Object(o, scope)
     fail(Issues::ILLEGAL_ASSIGNMENT, o)
   end
 
   # Assign value to named variable.
   # The '$' sign is never part of the name.
   # @example In Puppet DSL
   #   $name = value
   # @param name [String] name of variable without $
   # @param value [Object] value to assign to the variable
   # @param o [Puppet::Pops::Model::PopsObject] originating instruction
   # @param scope [Object] the runtime specific scope where evaluation should take place
   # @return [value<Object>]
   #
   def assign_String(name, value, o, scope)
     if name =~ /::/
       fail(Issues::CROSS_SCOPE_ASSIGNMENT, o.left_expr, {:name => name})
     end
     set_variable(name, value, o, scope)
     value
   end
 
   def assign_Numeric(n, value, o, scope)
     fail(Issues::ILLEGAL_NUMERIC_ASSIGNMENT, o.left_expr, {:varname => n.to_s})
   end
 
   # Catches all illegal assignment (e.g. 1 = 2, {'a'=>1} = 2, etc)
   #
   def assign_Object(name, value, o, scope)
     fail(Issues::ILLEGAL_ASSIGNMENT, o)
   end
 
   def eval_Factory(o, scope)
     evaluate(o.current, scope)
   end
 
   # Evaluates any object not evaluated to something else to itself.
   def eval_Object o, scope
     o
   end
 
   # Allows nil to be used as a Nop, Evaluates to nil
   def eval_NilClass(o, scope)
     nil
   end
 
   # Evaluates Nop to nil.
   def eval_Nop(o, scope)
     nil
   end
 
   # Captures all LiteralValues not handled elsewhere.
   #
   def eval_LiteralValue(o, scope)
     o.value
   end
 
   # Reserved Words fail to evaluate
   #
   def eval_ReservedWord(o, scope)
     fail(Puppet::Pops::Issues::RESERVED_WORD, o, {:word => o.word})
   end
 
   def eval_LiteralDefault(o, scope)
     :default
   end
 
   def eval_LiteralUndef(o, scope)
     nil
   end
 
   # A QualifiedReference (i.e. a  capitalized qualified name such as Foo, or Foo::Bar) evaluates to a PType
   #
   def eval_QualifiedReference(o, scope)
     @@type_parser.interpret(o)
   end
 
   def eval_NotExpression(o, scope)
     ! is_true?(evaluate(o.expr, scope))
   end
 
   def eval_UnaryMinusExpression(o, scope)
     - coerce_numeric(evaluate(o.expr, scope), o, scope)
   end
 
   def eval_UnfoldExpression(o, scope)
     candidate = evaluate(o.expr, scope)
     case candidate
     when Array
       candidate
     when Hash
       candidate.to_a
     else
       # turns anything else into an array (so result can be unfolded)
       [candidate]
     end
   end
 
   # Abstract evaluation, returns array [left, right] with the evaluated result of left_expr and
   # right_expr
   # @return <Array<Object, Object>> array with result of evaluating left and right expressions
   #
   def eval_BinaryExpression o, scope
     [ evaluate(o.left_expr, scope), evaluate(o.right_expr, scope) ]
   end
 
   # Evaluates assignment with operators =, +=, -= and
   #
   # @example Puppet DSL
   #   $a = 1
   #   $a += 1
   #   $a -= 1
   #
   def eval_AssignmentExpression(o, scope)
     name = lvalue(o.left_expr, scope)
     value = evaluate(o.right_expr, scope)
 
     if o.operator == :'='
       assign(name, value, o, scope)
     else
       fail(Issues::UNSUPPORTED_OPERATOR, o, {:operator => o.operator})
     end
     value
   end
 
   ARITHMETIC_OPERATORS = [:'+', :'-', :'*', :'/', :'%', :'<<', :'>>']
   COLLECTION_OPERATORS = [:'+', :'-', :'<<']
 
   # Handles binary expression where lhs and rhs are array/hash or numeric and operator is +, - , *, % / << >>
   #
   def eval_ArithmeticExpression(o, scope)
     left = evaluate(o.left_expr, scope)
     right = evaluate(o.right_expr, scope)
 
     begin
       result = calculate(left, right, o.operator, o.left_expr, o.right_expr, scope)
     rescue ArgumentError => e
       fail(Issues::RUNTIME_ERROR, o, {:detail => e.message}, e)
     end
     result
   end
 
 
   # Handles binary expression where lhs and rhs are array/hash or numeric and operator is +, - , *, % / << >>
   #
   def calculate(left, right, operator, left_o, right_o, scope)
     unless ARITHMETIC_OPERATORS.include?(operator)
       fail(Issues::UNSUPPORTED_OPERATOR, left_o.eContainer, {:operator => o.operator})
     end
 
     if (left.is_a?(Array) || left.is_a?(Hash)) && COLLECTION_OPERATORS.include?(operator)
       # Handle operation on collections
       case operator
       when :'+'
         concatenate(left, right)
       when :'-'
         delete(left, right)
       when :'<<'
         unless left.is_a?(Array)
           fail(Issues::OPERATOR_NOT_APPLICABLE, left_o, {:operator => operator, :left_value => left})
         end
         left + [right]
       end
     else
       # Handle operation on numeric
       left = coerce_numeric(left, left_o, scope)
       right = coerce_numeric(right, right_o, scope)
       begin
         if operator == :'%' && (left.is_a?(Float) || right.is_a?(Float))
           # Deny users the fun of seeing severe rounding errors and confusing results
           fail(Issues::OPERATOR_NOT_APPLICABLE, left_o, {:operator => operator, :left_value => left})
         end
         result = left.send(operator, right)
       rescue NoMethodError => e
         fail(Issues::OPERATOR_NOT_APPLICABLE, left_o, {:operator => operator, :left_value => left})
       rescue ZeroDivisionError => e
         fail(Issues::DIV_BY_ZERO, right_o)
       end
       if result == INFINITY || result == -INFINITY
         fail(Issues::RESULT_IS_INFINITY, left_o, {:operator => operator})
       end
       result
     end
   end
 
   def eval_EppExpression(o, scope)
     scope["@epp"] = []
     evaluate(o.body, scope)
     result = scope["@epp"].join
     result
   end
 
   def eval_RenderStringExpression(o, scope)
     scope["@epp"] << o.value.dup
     nil
   end
 
   def eval_RenderExpression(o, scope)
     scope["@epp"] << string(evaluate(o.expr, scope), scope)
     nil
   end
 
   # Evaluates Puppet DSL ->, ~>, <-, and <~
   def eval_RelationshipExpression(o, scope)
     # First level evaluation, reduction to basic data types or puppet types, the relationship operator then translates this
     # to the final set of references (turning strings into references, which can not naturally be done by the main evaluator since
     # all strings should not be turned into references.
     #
     real = eval_BinaryExpression(o, scope)
     @@relationship_operator.evaluate(real, o, scope)
   end
 
   # Evaluates x[key, key, ...]
   #
   def eval_AccessExpression(o, scope)
     left = evaluate(o.left_expr, scope)
     keys = o.keys.nil? ? [] : o.keys.collect {|key| evaluate(key, scope) }
     Puppet::Pops::Evaluator::AccessOperator.new(o).access(left, scope, *keys)
   end
 
   # Evaluates <, <=, >, >=, and ==
   #
   def eval_ComparisonExpression o, scope
     left = evaluate(o.left_expr, scope)
     right = evaluate(o.right_expr, scope)
 
     begin
     # Left is a type
     if left.is_a?(Puppet::Pops::Types::PAnyType)
       case o.operator
       when :'=='
         @@type_calculator.equals(left,right)
 
       when :'!='
         !@@type_calculator.equals(left,right)
 
       when :'<'
         # left can be assigned to right, but they are not equal
         @@type_calculator.assignable?(right, left) && ! @@type_calculator.equals(left,right)
       when :'<='
         # left can be assigned to right
         @@type_calculator.assignable?(right, left)
       when :'>'
         # right can be assigned to left, but they are not equal
         @@type_calculator.assignable?(left,right) && ! @@type_calculator.equals(left,right)
       when :'>='
         # right can be assigned to left
         @@type_calculator.assignable?(left, right)
       else
         fail(Issues::UNSUPPORTED_OPERATOR, o, {:operator => o.operator})
       end
     else
       case o.operator
       when :'=='
         @@compare_operator.equals(left,right)
       when :'!='
         ! @@compare_operator.equals(left,right)
       when :'<'
         @@compare_operator.compare(left,right) < 0
       when :'<='
         @@compare_operator.compare(left,right) <= 0
       when :'>'
         @@compare_operator.compare(left,right) > 0
       when :'>='
         @@compare_operator.compare(left,right) >= 0
       else
         fail(Issues::UNSUPPORTED_OPERATOR, o, {:operator => o.operator})
       end
     end
     rescue ArgumentError => e
       fail(Issues::COMPARISON_NOT_POSSIBLE, o, {
         :operator => o.operator,
         :left_value => left,
         :right_value => right,
         :detail => e.message}, e)
     end
   end
 
   # Evaluates matching expressions with type, string or regexp rhs expression.
   # If RHS is a type, the =~ matches compatible (instance? of) type.
   #
   # @example
   #   x =~ /abc.*/
   # @example
   #   x =~ "abc.*/"
   # @example
   #   y = "abc"
   #   x =~ "${y}.*"
   # @example
   #   [1,2,3] =~ Array[Integer[1,10]]
   #
   # Note that a string is not instance? of Regexp, only Regular expressions are.
   # The Pattern type should instead be used as it is specified as subtype of String.
   #
   # @return [Boolean] if a match was made or not. Also sets $0..$n to matchdata in current scope.
   #
   def eval_MatchExpression o, scope
     left = evaluate(o.left_expr, scope)
     pattern = evaluate(o.right_expr, scope)
 
     # matches RHS types as instance of for all types except a parameterized Regexp[R]
     if pattern.is_a?(Puppet::Pops::Types::PAnyType)
       # evaluate as instance? of type check
       matched = @@type_calculator.instance?(pattern, left)
       # convert match result to Boolean true, or false
       return o.operator == :'=~' ? !!matched : !matched
     end
 
     begin
       pattern = Regexp.new(pattern) unless pattern.is_a?(Regexp)
     rescue StandardError => e
       fail(Issues::MATCH_NOT_REGEXP, o.right_expr, {:detail => e.message}, e)
     end
     unless left.is_a?(String)
       fail(Issues::MATCH_NOT_STRING, o.left_expr, {:left_value => left})
     end
 
     matched = pattern.match(left) # nil, or MatchData
     set_match_data(matched,scope) # creates ephemeral
 
     # convert match result to Boolean true, or false
     o.operator == :'=~' ? !!matched : !matched
   end
 
   # Evaluates Puppet DSL `in` expression
   #
   def eval_InExpression o, scope
     left = evaluate(o.left_expr, scope)
     right = evaluate(o.right_expr, scope)
     @@compare_operator.include?(right, left, scope)
   end
 
   # @example
   #   $a and $b
   # b is only evaluated if a is true
   #
   def eval_AndExpression o, scope
     is_true?(evaluate(o.left_expr, scope)) ? is_true?(evaluate(o.right_expr, scope)) : false
   end
 
   # @example
   #   a or b
   # b is only evaluated if a is false
   #
   def eval_OrExpression o, scope
     is_true?(evaluate(o.left_expr, scope)) ? true : is_true?(evaluate(o.right_expr, scope))
   end
 
   # Evaluates each entry of the literal list and creates a new Array
   # Supports unfolding of entries
   # @return [Array] with the evaluated content
   #
   def eval_LiteralList o, scope
     unfold([], o.values, scope)
   end
 
   # Evaluates each entry of the literal hash and creates a new Hash.
   # @return [Hash] with the evaluated content
   #
   def eval_LiteralHash o, scope
     # optimized
     o.entries.reduce({}) {|h,entry| h[evaluate(entry.key, scope)] = evaluate(entry.value, scope); h }
   end
 
   # Evaluates all statements and produces the last evaluated value
   #
   def eval_BlockExpression o, scope
     r = nil
     o.statements.each {|s| r = evaluate(s, scope)}
     r
   end
 
   # Performs optimized search over case option values, lazily evaluating each
   # until there is a match. If no match is found, the case expression's default expression
   # is evaluated (it may be nil or Nop if there is no default, thus producing nil).
   # If an option matches, the result of evaluating that option is returned.
   # @return [Object, nil] what a matched option returns, or nil if nothing matched.
   #
   def eval_CaseExpression(o, scope)
     # memo scope level before evaluating test - don't want a match in the case test to leak $n match vars
     # to expressions after the case expression.
     #
     with_guarded_scope(scope) do
       test = evaluate(o.test, scope)
       result = nil
       the_default = nil
       if o.options.find do |co|
         # the first case option that matches
         if co.values.find do |c|
           case c
           when Puppet::Pops::Model::LiteralDefault
             the_default = co.then_expr
             is_match?(test, evaluate(c, scope), c, scope)
           when Puppet::Pops::Model::UnfoldExpression
             # not ideal for error reporting, since it is not known which unfolded result
             # that caused an error - the entire unfold expression is blamed (i.e. the var c, passed to is_match?)
             evaluate(c, scope).any? {|v| is_match?(test, v, c, scope) }
           else
             is_match?(test, evaluate(c, scope), c, scope)
           end
         end
         result = evaluate(co.then_expr, scope)
         true # the option was picked
         end
       end
         result # an option was picked, and produced a result
       else
         evaluate(the_default, scope) # evaluate the default (should be a nop/nil) if there is no default).
       end
     end
   end
 
   # Evaluates a CollectExpression by creating a collector transformer. The transformer
   # will evaulate the collection, create the appropriate collector, and hand it off
   # to the compiler to collect the resources specified by the query.
   #
   def eval_CollectExpression o, scope
     Puppet::Pops::Evaluator::CollectorTransformer.new().transform(o,scope)
   end
 
   def eval_ParenthesizedExpression(o, scope)
     evaluate(o.expr, scope)
   end
 
   # This evaluates classes, nodes and resource type definitions to nil, since 3x:
   # instantiates them, and evaluates their parameters and body. This is achieved by
   # providing bridge AST classes in Puppet::Parser::AST::PopsBridge that bridges a
   # Pops Program and a Pops Expression.
   #
   # Since all Definitions are handled "out of band", they are treated as a no-op when
   # evaluated.
   #
   def eval_Definition(o, scope)
     nil
   end
 
   def eval_Program(o, scope)
     evaluate(o.body, scope)
   end
 
   # Produces Array[PAnyType], an array of resource references
   #
   def eval_ResourceExpression(o, scope)
     exported = o.exported
     virtual = o.virtual
 
     # Get the type name
     type_name =
     if (tmp_name = o.type_name).is_a?(Puppet::Pops::Model::QualifiedName)
       tmp_name.value # already validated as a name
     else
       type_name_acceptable =
       case o.type_name
       when Puppet::Pops::Model::QualifiedReference
         true
       when Puppet::Pops::Model::AccessExpression
         o.type_name.left_expr.is_a?(Puppet::Pops::Model::QualifiedReference)
       end
 
       evaluated_name = evaluate(tmp_name, scope)
       unless type_name_acceptable
         actual = type_calculator.generalize!(type_calculator.infer(evaluated_name)).to_s
         fail(Puppet::Pops::Issues::ILLEGAL_RESOURCE_TYPE, o.type_name, {:actual => actual})
       end
 
       # must be a CatalogEntry subtype
       case evaluated_name
       when Puppet::Pops::Types::PHostClassType
         unless evaluated_name.class_name.nil?
           fail(Puppet::Pops::Issues::ILLEGAL_RESOURCE_TYPE, o.type_name, {:actual=> evaluated_name.to_s})
         end
         'class'
 
       when Puppet::Pops::Types::PResourceType
         unless evaluated_name.title().nil?
           fail(Puppet::Pops::Issues::ILLEGAL_RESOURCE_TYPE, o.type_name, {:actual=> evaluated_name.to_s})
         end
         evaluated_name.type_name # assume validated
 
       else
         actual = type_calculator.generalize!(type_calculator.infer(evaluated_name)).to_s
         fail(Puppet::Pops::Issues::ILLEGAL_RESOURCE_TYPE, o.type_name, {:actual=>actual})
       end
     end
 
     # This is a runtime check - the model is valid, but will have runtime issues when evaluated
     # and storeconfigs is not set.
     if(o.exported)
       optionally_fail(Puppet::Pops::Issues::RT_NO_STORECONFIGS_EXPORT, o);
     end
 
     titles_to_body = {}
     body_to_titles = {}
     body_to_params = {}
 
     # titles are evaluated before attribute operations
     o.bodies.map do | body |
       titles = evaluate(body.title, scope)
 
       # Title may not be nil
       # Titles may be given as an array, it is ok if it is empty, but not if it contains nil entries
       # Titles may not be an empty String
       # Titles must be unique in the same resource expression
       # There may be a :default entry, its entries apply with lower precedence
       #
       if titles.nil?
         fail(Puppet::Pops::Issues::MISSING_TITLE, body.title)
       end
       titles = [titles].flatten
 
       # Check types of evaluated titles and duplicate entries
       titles.each_with_index do |title, index|
         if title.nil?
           fail(Puppet::Pops::Issues::MISSING_TITLE_AT, body.title, {:index => index})
 
         elsif !title.is_a?(String) && title != :default
           actual = type_calculator.generalize!(type_calculator.infer(title)).to_s
           fail(Puppet::Pops::Issues::ILLEGAL_TITLE_TYPE_AT, body.title, {:index => index, :actual => actual})
 
         elsif title == EMPTY_STRING
          fail(Puppet::Pops::Issues::EMPTY_STRING_TITLE_AT, body.title, {:index => index})
 
         elsif titles_to_body[title]
           fail(Puppet::Pops::Issues::DUPLICATE_TITLE, o, {:title => title})
         end
         titles_to_body[title] = body
       end
 
       # Do not create a real instance from the :default case
       titles.delete(:default)
 
       body_to_titles[body] = titles
 
       # Store evaluated parameters in a hash associated with the body, but do not yet create resource
       # since the entry containing :defaults may appear later
       body_to_params[body] = body.operations.reduce({}) do |param_memo, op|
         params = evaluate(op, scope)
         params = [params] unless params.is_a?(Array)
         params.each do |p|
           if param_memo.include? p.name
             fail(Puppet::Pops::Issues::DUPLICATE_ATTRIBUTE, o, {:attribute => p.name})
           end
           param_memo[p.name] = p
         end
         param_memo
       end
     end
 
     # Titles and Operations have now been evaluated and resources can be created
     # Each production is a PResource, and an array of all is produced as the result of
     # evaluating the ResourceExpression.
     #
     defaults_hash = body_to_params[titles_to_body[:default]] || {}
     o.bodies.map do | body |
       titles = body_to_titles[body]
       params = defaults_hash.merge(body_to_params[body] || {})
       create_resources(o, scope, virtual, exported, type_name, titles, params.values)
     end.flatten.compact
   end
 
   def eval_ResourceOverrideExpression(o, scope)
     evaluated_resources = evaluate(o.resources, scope)
     evaluated_parameters = o.operations.map { |op| evaluate(op, scope) }
     create_resource_overrides(o, scope, [evaluated_resources].flatten, evaluated_parameters)
     evaluated_resources
   end
 
   # Produces 3x parameter
   def eval_AttributeOperation(o, scope)
     create_resource_parameter(o, scope, o.attribute_name, evaluate(o.value_expr, scope), o.operator)
   end
 
   def eval_AttributesOperation(o, scope)
     hashed_params = evaluate(o.expr, scope)
     unless hashed_params.is_a?(Hash)
       actual = type_calculator.generalize!(type_calculator.infer(hashed_params)).to_s
       fail(Puppet::Pops::Issues::TYPE_MISMATCH, o.expr, {:expected => 'Hash', :actual => actual})
     end
     hashed_params.map { |k,v| create_resource_parameter(o, scope, k, v, :'=>') }
   end
 
   # Sets default parameter values for a type, produces the type
   #
   def eval_ResourceDefaultsExpression(o, scope)
     type = evaluate(o.type_ref, scope)
     type_name =
     if type.is_a?(Puppet::Pops::Types::PResourceType) && !type.type_name.nil? && type.title.nil?
       type.type_name # assume it is a valid name
     else
       actual = type_calculator.generalize!(type_calculator.infer(type))
       fail(Issues::ILLEGAL_RESOURCE_TYPE, o.type_ref, {:actual => actual})
     end
     evaluated_parameters = o.operations.map {|op| evaluate(op, scope) }
     create_resource_defaults(o, scope, type_name, evaluated_parameters)
     # Produce the type
     type
   end
 
   # Evaluates function call by name.
   #
   def eval_CallNamedFunctionExpression(o, scope)
     # The functor expression is not evaluated, it is not possible to select the function to call
     # via an expression like $a()
     case o.functor_expr
     when Puppet::Pops::Model::QualifiedName
       # ok
     when Puppet::Pops::Model::RenderStringExpression
       # helpful to point out this easy to make Epp error
       fail(Issues::ILLEGAL_EPP_PARAMETERS, o)
     else
       fail(Issues::ILLEGAL_EXPRESSION, o.functor_expr, {:feature=>'function name', :container => o})
     end
     name = o.functor_expr.value
-
-    evaluated_arguments = unfold([], o.arguments, scope)
-
-    # wrap lambda in a callable block if it is present
-    evaluated_arguments << Puppet::Pops::Evaluator::Closure.new(self, o.lambda, scope) if o.lambda
-    call_function(name, evaluated_arguments, o, scope)
+    call_function_with_block(name, unfold([], o.arguments, scope), o, scope)
   end
 
   # Evaluation of CallMethodExpression handles a NamedAccessExpression functor (receiver.function_name)
   #
   def eval_CallMethodExpression(o, scope)
     unless o.functor_expr.is_a? Puppet::Pops::Model::NamedAccessExpression
       fail(Issues::ILLEGAL_EXPRESSION, o.functor_expr, {:feature=>'function accessor', :container => o})
     end
     receiver = evaluate(o.functor_expr.left_expr, scope)
     name = o.functor_expr.right_expr
     unless name.is_a? Puppet::Pops::Model::QualifiedName
       fail(Issues::ILLEGAL_EXPRESSION, o.functor_expr, {:feature=>'function name', :container => o})
     end 
     name = name.value # the string function name
+    call_function_with_block(name, unfold([receiver], o.arguments || [], scope), o, scope)
+  end
+
+  def call_function_with_block(name, evaluated_arguments, o, scope)
+    if o.lambda.nil?
+      call_function(name, evaluated_arguments, o, scope)
+    else
+      closure = Puppet::Pops::Evaluator::Closure.new(self, o.lambda, scope)
+      call_function(name, evaluated_arguments, o, scope, &proc_from_closure(closure))
+    end
+  end
+  private :call_function_with_block
+
+  # Creates a Proc with an arity count that matches the parameters of the given closure. The arity will
+  # be correct up to 10 parameters and then default to varargs (-1)
+  #
+  def proc_from_closure(closure)
+    return Puppet::Pops::Evaluator::PuppetProc.new(closure) { |*args| closure.call(*args) } unless RUBY_VERSION[0,3] == '1.8'
 
-    evaluated_arguments = unfold([receiver], o.arguments || [], scope)
+    # This code is required since a Proc isn't propagated by reference in Ruby 1.8.x. It produces a standard
+    # Proc that has correct arity as a replacement for the otherwise used PuppetProc
+    # TODO: Remove when Ruby 1.8.x support is dropped
+    arity = closure.parameters.reduce(0) do |memo, param|
+      count = memo + 1
+      break -count if param.captures_rest || !param.value.nil?
+      count
+    end
 
-    # wrap lambda in a callable block if it is present
-    evaluated_arguments << Puppet::Pops::Evaluator::Closure.new(self, o.lambda, scope) if o.lambda
-    call_function(name, evaluated_arguments, o, scope)
+    case arity
+    when 0
+      proc { || closure.call }
+    when 1
+      proc { |a| closure.call(a) }
+    when 2
+      proc { |a, b| closure.call(a, b) }
+    when 3
+      proc { |a, b, c| closure.call(a, b, c) }
+    when 4
+      proc { |a, b, c, d| closure.call(a, b, c, d) }
+    when 5
+      proc { |a, b, c, d, e| closure.call(a, b, c, d, e) }
+    when 6
+      proc { |a, b, c, d, e, f| closure.call(a, b, c, d, e, f) }
+    when 7
+      proc { |a, b, c, d, e, f, g| closure.call(a, b, c, d, e, f, g) }
+    when 8
+      proc { |a, b, c, d, e, f, g, h| closure.call(a, b, c, d, e, f, g, h) }
+    when 9
+      proc { |a, b, c, d, e, f, g, h, i| closure.call(a, b, c, d, e, f, g, h, i) }
+    when 10
+      proc { |a, b, c, d, e, f, g, h, i, j| closure.call(a, b, c, d, e, f, g, h, i, j) }
+    when -1
+      proc { |*v| closure.call(*v) }
+    when -2
+      proc { |a, *v| closure.call(a, *v) }
+    when -3
+      proc { |a, b, *v| closure.call(a, b, *v) }
+    when -4
+      proc { |a, b, c, *v| closure.call(a, b, c, *v) }
+    when -5
+      proc { |a, b, c, d, *v| closure.call(a, b, c, d, *v) }
+    when -6
+      proc { |a, b, c, d, e, *v| closure.call(a, b, c, d, e, *v) }
+    when -7
+      proc { |a, b, c, d, e, f, *v| closure.call(a, b, c, d, e, f, *v) }
+    when -8
+      proc { |a, b, c, d, e, f, g, *v| closure.call(a, b, c, d, e, f, g, *v) }
+    when -9
+      proc { |a, b, c, d, e, f, g, h, *v| closure.call(a, b, c, d, e, f,g, h, *v) }
+    when -10
+      proc { |a, b, c, d, e, f, g, h, i, *v| closure.call(a, b, c, d, e, f,g, h, i, *v) }
+    else
+      proc { |*a| closure.call(*a) }
+    end
   end
+  private :proc_from_closure
 
   # @example
   #   $x ? { 10 => true, 20 => false, default => 0 }
   #
   def eval_SelectorExpression o, scope
     # memo scope level before evaluating test - don't want a match in the case test to leak $n match vars
     # to expressions after the selector expression.
     #
     with_guarded_scope(scope) do
       test = evaluate(o.left_expr, scope)
       the_default = nil
       selected = o.selectors.find do |s|
         me = s.matching_expr
         case me
         when Puppet::Pops::Model::LiteralDefault
           the_default = s.value_expr
           false
         when Puppet::Pops::Model::UnfoldExpression
           # not ideal for error reporting, since it is not known which unfolded result
           # that caused an error - the entire unfold expression is blamed (i.e. the var c, passed to is_match?)
           evaluate(me, scope).any? {|v| is_match?(test, v, me, scope) }
         else
           is_match?(test, evaluate(me, scope), me, scope)
         end
       end
       if selected
         evaluate(selected.value_expr, scope)
       elsif the_default
         evaluate(the_default, scope)
       else
         fail(Issues::UNMATCHED_SELECTOR, o.left_expr, :param_value => test)
       end
     end
   end
 
   # SubLocatable is simply an expression that holds location information
   def eval_SubLocatedExpression o, scope
     evaluate(o.expr, scope)
   end
 
   # Evaluates Puppet DSL Heredoc
   def eval_HeredocExpression o, scope
     result = evaluate(o.text_expr, scope)
     assert_external_syntax(scope, result, o.syntax, o.text_expr)
     result
   end
 
   # Evaluates Puppet DSL `if`
   def eval_IfExpression o, scope
     with_guarded_scope(scope) do
       if is_true?(evaluate(o.test, scope))
         evaluate(o.then_expr, scope)
       else
         evaluate(o.else_expr, scope)
       end
     end
   end
 
   # Evaluates Puppet DSL `unless`
   def eval_UnlessExpression o, scope
     with_guarded_scope(scope) do
       unless is_true?(evaluate(o.test, scope))
         evaluate(o.then_expr, scope)
       else
         evaluate(o.else_expr, scope)
       end
     end
   end
 
   # Evaluates a variable (getting its value)
   # The evaluator is lenient; any expression producing a String is used as a name
   # of a variable.
   #
   def eval_VariableExpression o, scope
     # Evaluator is not too fussy about what constitutes a name as long as the result
     # is a String and a valid variable name
     #
     name = evaluate(o.expr, scope)
 
     # Should be caught by validation, but make this explicit here as well, or mysterious evaluation issues
     # may occur for some evaluation use cases.
     case name
     when String
     when Numeric
     else
       fail(Issues::ILLEGAL_VARIABLE_EXPRESSION, o.expr)
     end
     get_variable_value(name, o, scope)
   end
 
   # Evaluates double quoted strings that may contain interpolation
   #
   def eval_ConcatenatedString o, scope
     o.segments.collect {|expr| string(evaluate(expr, scope), scope)}.join
   end
 
 
   # If the wrapped expression is a QualifiedName, it is taken as the name of a variable in scope.
   # Note that this is different from the 3.x implementation, where an initial qualified name
   # is accepted. (e.g. `"---${var + 1}---"` is legal. This implementation requires such concrete
   # syntax to be expressed in a model as `(TextExpression (+ (Variable var) 1)` - i.e. moving the decision to
   # the parser.
   #
   # Semantics; the result of an expression is turned into a string, nil is silently transformed to empty
   # string.
   # @return [String] the interpolated result
   #
   def eval_TextExpression o, scope
     if o.expr.is_a?(Puppet::Pops::Model::QualifiedName)
       string(get_variable_value(o.expr.value, o, scope), scope)
     else
       string(evaluate(o.expr, scope), scope)
     end
   end
 
   def string_Object(o, scope)
     o.to_s
   end
 
   def string_Symbol(o, scope)
     if :undef == o  # optimized comparison 1.44 vs 1.95
       EMPTY_STRING
     else
       o.to_s
     end
   end
 
   def string_Array(o, scope)
     "[#{o.map {|e| string(e, scope)}.join(COMMA_SEPARATOR)}]"
   end
 
   def string_Hash(o, scope)
     "{#{o.map {|k,v| "#{string(k, scope)} => #{string(v, scope)}"}.join(COMMA_SEPARATOR)}}"
   end
 
   def string_Regexp(o, scope)
     "/#{o.source}/"
   end
 
   def string_PAnyType(o, scope)
     @@type_calculator.string(o)
   end
 
   # Produces concatenation / merge of x and y.
   #
   # When x is an Array, y of type produces:
   #
   # * Array => concatenation `[1,2], [3,4] => [1,2,3,4]`
   # * Hash => concatenation of hash as array `[key, value, key, value, ...]`
   # * any other => concatenation of single value
   #
   # When x is a Hash, y of type produces:
   #
   # * Array => merge of array interpreted as `[key, value, key, value,...]`
   # * Hash => a merge, where entries in `y` overrides
   # * any other => error
   #
   # When x is something else, wrap it in an array first.
   #
   # When x is nil, an empty array is used instead.
   #
   # @note to concatenate an Array, nest the array - i.e. `[1,2], [[2,3]]`
   #
   # @overload concatenate(obj_x, obj_y)
   #   @param obj_x [Object] object to wrap in an array and concatenate to; see other overloaded methods for return type
   #   @param ary_y [Object] array to concatenate at end of `ary_x`
   #   @return [Object] wraps obj_x in array before using other overloaded option based on type of obj_y
   # @overload concatenate(ary_x, ary_y)
   #   @param ary_x [Array] array to concatenate to
   #   @param ary_y [Array] array to concatenate at end of `ary_x`
   #   @return [Array] new array with `ary_x` + `ary_y`
   # @overload concatenate(ary_x, hsh_y)
   #   @param ary_x [Array] array to concatenate to
   #   @param hsh_y [Hash] converted to array form, and concatenated to array
   #   @return [Array] new array with `ary_x` + `hsh_y` converted to array
   # @overload concatenate (ary_x, obj_y)
   #   @param ary_x [Array] array to concatenate to
   #   @param obj_y [Object] non array or hash object to add to array
   #   @return [Array] new array with `ary_x` + `obj_y` added as last entry
   # @overload concatenate(hsh_x, ary_y)
   #   @param hsh_x [Hash] the hash to merge with
   #   @param ary_y [Array] array interpreted as even numbered sequence of key, value merged with `hsh_x`
   #   @return [Hash] new hash with `hsh_x` merged with `ary_y` interpreted as hash in array form
   # @overload concatenate(hsh_x, hsh_y)
   #   @param hsh_x [Hash] the hash to merge to
   #   @param hsh_y [Hash] hash merged with `hsh_x`
   #   @return [Hash] new hash with `hsh_x` merged with `hsh_y`
   # @raise [ArgumentError] when `xxx_x` is neither an Array nor a Hash
   # @raise [ArgumentError] when `xxx_x` is a Hash, and `xxx_y` is neither Array nor Hash.
   #
   def concatenate(x, y)
     x = [x] unless x.is_a?(Array) || x.is_a?(Hash)
     case x
     when Array
       y = case y
       when Array then y
       when Hash  then y.to_a
       else
         [y]
       end
       x + y # new array with concatenation
     when Hash
       y = case y
       when Hash then y
       when Array
         # Hash[[a, 1, b, 2]] => {}
         # Hash[a,1,b,2] => {a => 1, b => 2}
         # Hash[[a,1], [b,2]] => {[a,1] => [b,2]}
         # Hash[[[a,1], [b,2]]] => {a => 1, b => 2}
         # Use type calcultor to determine if array is Array[Array[?]], and if so use second form
         # of call
         t = @@type_calculator.infer(y)
         if t.element_type.is_a? Puppet::Pops::Types::PArrayType
           Hash[y]
         else
           Hash[*y]
         end
       else
         raise ArgumentError.new("Can only append Array or Hash to a Hash")
       end
       x.merge y # new hash with overwrite
     else
       raise ArgumentError.new("Can only append to an Array or a Hash.")
     end
   end
 
   # Produces the result x \ y (set difference)
   # When `x` is an Array, `y` is transformed to an array and then all matching elements removed from x.
   # When `x` is a Hash, all contained keys are removed from x as listed in `y` if it is an Array, or all its keys if it is a Hash.
   # The difference is returned. The given `x` and `y` are not modified by this operation.
   # @raise [ArgumentError] when `x` is neither an Array nor a Hash
   #
   def delete(x, y)
     result = x.dup
     case x
     when Array
       y = case y
       when Array then y
       when Hash then y.to_a
       else
         [y]
       end
       y.each {|e| result.delete(e) }
     when Hash
       y = case y
       when Array then y
       when Hash then y.keys
       else
         [y]
       end
       y.each {|e| result.delete(e) }
     else
       raise ArgumentError.new("Can only delete from an Array or Hash.")
     end
     result
   end
 
   # Implementation of case option matching.
   #
   # This is the type of matching performed in a case option, using == for every type
   # of value except regular expression where a match is performed.
   #
   def is_match? left, right, o, scope
     if right.is_a?(Regexp)
       return false unless left.is_a? String
       matched = right.match(left)
       set_match_data(matched, scope) # creates or clears ephemeral
       !!matched # convert to boolean
     elsif right.is_a?(Puppet::Pops::Types::PAnyType)
       # right is a type and left is not - check if left is an instance of the given type
       # (The reverse is not terribly meaningful - computing which of the case options that first produces
       # an instance of a given type).
       #
       @@type_calculator.instance?(right, left)
     else
       # Handle equality the same way as the language '==' operator (case insensitive etc.)
       @@compare_operator.equals(left,right)
     end
   end
 
   def with_guarded_scope(scope)
     scope_memo = get_scope_nesting_level(scope)
     begin
       yield
     ensure
       set_scope_nesting_level(scope, scope_memo)
     end
   end
 
   # Maps the expression in the given array to their product except for UnfoldExpressions which are first unfolded.
   # The result is added to the given result Array.
   # @param result [Array] Where to add the result (may contain information to add to)
   # @param array [Array[Puppet::Pops::Model::Expression] the expressions to map
   # @param scope [Puppet::Parser::Scope] the scope to evaluate in
   # @return [Array] the given result array with content added from the operation
   #
   def unfold(result, array, scope)
     array.each do |x|
       if x.is_a?(Puppet::Pops::Model::UnfoldExpression)
         result.concat(evaluate(x, scope))
       else
         result << evaluate(x, scope)
       end
     end
     result
   end
   private :unfold
 
 end
diff --git a/lib/puppet/pops/evaluator/puppet_proc.rb b/lib/puppet/pops/evaluator/puppet_proc.rb
new file mode 100644
index 000000000..33e71db26
--- /dev/null
+++ b/lib/puppet/pops/evaluator/puppet_proc.rb
@@ -0,0 +1,69 @@
+# Complies with Proc API by mapping a Puppet::Pops::Evaluator::Closure to a ruby Proc.
+# Creating and passing an instance of this class instead of just a plain block makes
+# it possible to inherit the parameter info and arity from the closure. Advanced users
+# may also access the closure itself. The Puppet::Pops::Functions::Dispatcher uses this
+# when it needs to get the Callable type of the closure.
+#
+# The class is part of the Puppet Function API for Ruby and thus public API but a user
+# should never create an instance of this class.
+#
+# @api public
+class Puppet::Pops::Evaluator::PuppetProc < Proc
+  # Creates a new instance from a closure and a block that will dispatch
+  # all parameters to the closure. The block must be similar to:
+  #
+  #   { |*args| closure.call(*args) }
+  #
+  # @param closure [Puppet::Pops::Evaluator::Closure] The closure to map
+  # @param &block [Block] The varargs block that invokes the closure.call method
+  #
+  # @api private
+  def self.new(closure, &block)
+    proc = super(&block)
+    proc.instance_variable_set(:@closure, closure)
+    proc
+  end
+
+  # @return  [Puppet::Pops::Evaluator::Closure] the mapped closure
+  # @api public
+  attr_reader :closure
+
+  # @overrides Block.lambda?
+  # @return [Boolean] always false since this proc doesn't do the Ruby lambda magic
+  # @api public
+  def lambda?
+    false
+  end
+
+  # Maps the closure parameters to standard Block parameter info where each
+  # parameter is represented as a two element Array where the first
+  # element is :req, :opt, or :rest and the second element is the name
+  # of the parameter.
+  #
+  # @return [Array<Array<Symbol>>] array of parameter info pairs
+  # @overrides Block.parameters
+  # @api public
+  def parameters
+    @closure.parameters.map do |param|
+      sym = param.name.to_sym
+      if param.captures_rest
+        [ :rest, sym ]
+      elsif param.value
+        [ :opt, sym ]
+      else
+        [ :req, sym ]
+      end
+    end
+  end
+
+  # @return [Fixnum] the arity of the block
+  # @overrides Block.arity
+  # @api public
+  def arity
+    parameters.reduce(0) do |memo, param|
+      count = memo + 1
+      break -count unless param[0] == :req
+      count
+    end
+  end
+end
diff --git a/lib/puppet/pops/evaluator/runtime3_support.rb b/lib/puppet/pops/evaluator/runtime3_support.rb
index 453b72efd..91031a51b 100644
--- a/lib/puppet/pops/evaluator/runtime3_support.rb
+++ b/lib/puppet/pops/evaluator/runtime3_support.rb
@@ -1,482 +1,482 @@
 # A module with bindings between the new evaluator and the 3x runtime.
 # The intention is to separate all calls into scope, compiler, resource, etc. in this module
 # to make it easier to later refactor the evaluator for better implementations of the 3x classes.
 #
 # @api private
 module Puppet::Pops::Evaluator::Runtime3Support
 
   NAME_SPACE_SEPARATOR = '::'.freeze
 
   # Fails the evaluation of _semantic_ with a given issue.
   #
   # @param issue [Puppet::Pops::Issue] the issue to report
   # @param semantic [Puppet::Pops::ModelPopsObject] the object for which evaluation failed in some way. Used to determine origin.
   # @param options [Hash] hash of optional named data elements for the given issue
   # @return [!] this method does not return
   # @raise [Puppet::ParseError] an evaluation error initialized from the arguments (TODO: Change to EvaluationError?)
   #
   def fail(issue, semantic, options={}, except=nil)
     optionally_fail(issue, semantic, options, except)
     # an error should have been raised since fail always fails
     raise ArgumentError, "Internal Error: Configuration of runtime error handling wrong: should have raised exception"
   end
 
   # Optionally (based on severity) Fails the evaluation of _semantic_ with a given issue
   # If the given issue is configured to be of severity < :error it is only reported, and the function returns.
   #
   # @param issue [Puppet::Pops::Issue] the issue to report
   # @param semantic [Puppet::Pops::ModelPopsObject] the object for which evaluation failed in some way. Used to determine origin.
   # @param options [Hash] hash of optional named data elements for the given issue
   # @return [!] this method does not return
   # @raise [Puppet::ParseError] an evaluation error initialized from the arguments (TODO: Change to EvaluationError?)
   #
   def optionally_fail(issue, semantic, options={}, except=nil)
     if except.nil?
       # Want a stacktrace, and it must be passed as an exception
       begin
        raise EvaluationError.new()
       rescue EvaluationError => e
         except = e
       end
     end
     diagnostic_producer.accept(issue, semantic, options, except)
   end
 
   # Binds the given variable name to the given value in the given scope.
   # The reference object `o` is intended to be used for origin information - the 3x scope implementation
   # only makes use of location when there is an error. This is now handled by other mechanisms; first a check
   # is made if a variable exists and an error is raised if attempting to change an immutable value. Errors
   # in name, numeric variable assignment etc. have also been validated prior to this call. In the event the
   # scope.setvar still raises an error, the general exception handling for evaluation of the assignment
   # expression knows about its location. Because of this, there is no need to extract the location for each
   # setting (extraction is somewhat expensive since 3x requires line instead of offset).
   #
   def set_variable(name, value, o, scope)
     # Scope also checks this but requires that location information are passed as options.
     # Those are expensive to calculate and a test is instead made here to enable failing with better information.
     # The error is not specific enough to allow catching it - need to check the actual message text.
     # TODO: Improve the messy implementation in Scope.
     #
     if scope.bound?(name)
       if Puppet::Parser::Scope::RESERVED_VARIABLE_NAMES.include?(name)
         fail(Puppet::Pops::Issues::ILLEGAL_RESERVED_ASSIGNMENT, o, {:name => name} )
       else
         fail(Puppet::Pops::Issues::ILLEGAL_REASSIGNMENT, o, {:name => name} )
       end
     end
     scope.setvar(name, value)
   end
 
   # Returns the value of the variable (nil is returned if variable has no value, or if variable does not exist)
   #
   def get_variable_value(name, o, scope)
     # Puppet 3x stores all variables as strings (then converts them back to numeric with a regexp... to see if it is a match variable)
     # Not ideal, scope should support numeric lookup directly instead.
     # TODO: consider fixing scope
     catch(:undefined_variable) {
       x = scope.lookupvar(name.to_s)
       # Must convert :undef back to nil - this can happen when an undefined variable is used in a
       # parameter's default value expression - there nil must be :undef to work with the rest of 3x.
       # Now that the value comes back to 4x it is changed to nil.
       return (x == :undef) ? nil : x
     }
     # It is always ok to reference numeric variables even if they are not assigned. They are always undef
     # if not set by a match expression.
     #
     unless name =~ Puppet::Pops::Patterns::NUMERIC_VAR_NAME
       fail(Puppet::Pops::Issues::UNKNOWN_VARIABLE, o, {:name => name})
     end
   end
 
   # Returns true if the variable of the given name is set in the given most nested scope. True is returned even if
   # variable is bound to nil.
   #
   def variable_bound?(name, scope)
     scope.bound?(name.to_s)
   end
 
   # Returns true if the variable is bound to a value or nil, in the scope or it's parent scopes.
   #
   def variable_exists?(name, scope)
     scope.exist?(name.to_s)
   end
 
   def set_match_data(match_data, scope)
     # See set_variable for rationale for not passing file and line to ephemeral_from.
     # NOTE: The 3x scope adds one ephemeral(match) to its internal stack per match that succeeds ! It never
     # clears anything. Thus a context that performs many matches will get very deep (there simply is no way to
     # clear the match variables without rolling back the ephemeral stack.)
     # This implementation does not attempt to fix this, it behaves the same bad way.
     unless match_data.nil?
       scope.ephemeral_from(match_data)
     end
   end
 
   # Creates a local scope with vairalbes set from a hash of variable name to value
   #
   def create_local_scope_from(hash, scope)
     # two dummy values are needed since the scope tries to give an error message (can not happen in this
     # case - it is just wrong, the error should be reported by the caller who knows in more detail where it
     # is in the source.
     #
     raise ArgumentError, "Internal error - attempt to create a local scope without a hash" unless hash.is_a?(Hash)
     scope.ephemeral_from(hash)
   end
 
   # Creates a nested match scope
   def create_match_scope_from(scope)
     # Create a transparent match scope (for future matches)
     scope.new_match_scope(nil)
   end
 
   def get_scope_nesting_level(scope)
     scope.ephemeral_level
   end
 
   def set_scope_nesting_level(scope, level)
     # Yup, 3x uses this method to reset the level, it also supports passing :all to destroy all 
     # ephemeral/local scopes - which is a sure way to create havoc.
     #
     scope.unset_ephemeral_var(level)
   end
 
   # Adds a relationship between the given `source` and `target` of the given `relationship_type`
   # @param source [Puppet:Pops::Types::PCatalogEntryType] the source end of the relationship (from)
   # @param target [Puppet:Pops::Types::PCatalogEntryType] the target end of the relationship (to)
   # @param relationship_type [:relationship, :subscription] the type of the relationship
   #
   def add_relationship(source, target, relationship_type, scope)
     # The 3x way is to record a Puppet::Parser::Relationship that is evaluated at the end of the compilation.
     # This means it is not possible to detect any duplicates at this point (and signal where an attempt is made to
     # add a duplicate. There is also no location information to signal the original place in the logic. The user will have
     # to go fish.
     # The 3.x implementation is based on Strings :-o, so the source and target must be transformed. The resolution is
     # done by Catalog#resource(type, title). To do that, it creates a Puppet::Resource since it is responsible for
     # translating the name/type/title and create index-keys used by the catalog. The Puppet::Resource has bizarre parsing of
     # the type and title (scan for [] that is interpreted as type/title (but it gets it wrong).
     # Moreover if the type is "" or "component", the type is Class, and if the type is :main, it is :main, all other cases
     # undergo capitalization of name-segments (foo::bar becomes Foo::Bar). (This was earlier done in the reverse by the parser).
     # Further, the title undergoes the same munging !!!
     #
     # That bug infested nest of messy logic needs serious Exorcism!
     #
     # Unfortunately it is not easy to simply call more intelligent methods at a lower level as the compiler evaluates the recorded
     # Relationship object at a much later point, and it is responsible for invoking all the messy logic.
     #
     # TODO: Revisit the below logic when there is a sane implementation of the catalog, compiler and resource. For now
     # concentrate on transforming the type references to what is expected by the wacky logic.
     #
     # HOWEVER, the Compiler only records the Relationships, and the only method it calls is @relationships.each{|x| x.evaluate(catalog) }
     # Which means a smarter Relationship class could do this right. Instead of obtaining the resource from the catalog using
     # the borked resource(type, title) which creates a resource for the purpose of looking it up, it needs to instead
     # scan the catalog's resources
     #
     # GAAAH, it is even worse!
     # It starts in the parser, which parses "File['foo']" into an AST::ResourceReference with type = File, and title = foo
     # This AST is evaluated by looking up the type/title in the scope - causing it to be loaded if it exists, and if not, the given
     # type name/title is used. It does not search for resource instances, only classes and types. It returns symbolic information
     # [type, [title, title]]. From this, instances of Puppet::Resource are created and returned. These only have type/title information
     # filled out. One or an array of resources are returned.
     # This set of evaluated (empty reference) Resource instances are then passed to the relationship operator. It creates a
     # Puppet::Parser::Relationship giving it a source and a target that are (empty reference) Resource instances. These are then remembered
     # until the relationship is evaluated by the compiler (at the end). When evaluation takes place, the (empty reference) Resource instances
     # are converted to String (!?! WTF) on the simple format "#{type}[#{title}]", and the catalog is told to find a resource, by giving
     # it this string. If it cannot find the resource it fails, else the before/notify parameter is appended with the target.
     # The search for the resource begin with (you guessed it) again creating an (empty reference) resource from type and title (WTF?!?!).
     # The catalog now uses the reference resource to compute a key [r.type, r.title.to_s] and also gets a uniqueness key from the
     # resource (This is only a reference type created from title and type). If it cannot find it with the first key, it uses the
     # uniqueness key to lookup.
     #
     # This is probably done to allow a resource type to munge/translate the title in some way (but it is quite unclear from the long
     # and convoluted path of evaluation.
     # In order to do this in a way that is similar to 3.x two resources are created to be used as keys.
     #
     # And if that is not enough, a source/target may be a Collector (a baked query that will be evaluated by the
     # compiler - it is simply passed through here for processing by the compiler at the right time).
     #
     if source.is_a?(Puppet::Parser::Collector) || source.is_a?(Puppet::Pops::Evaluator::Collectors::AbstractCollector)
       # use verbatim - behavior defined by 3x
       source_resource = source
     else
       # transform into the wonderful String representation in 3x
       type, title = Puppet::Pops::Evaluator::Runtime3Converter.instance.catalog_type_to_split_type_title(source)
       source_resource = Puppet::Resource.new(type, title)
     end
     if target.is_a?(Puppet::Parser::Collector) || target.is_a?(Puppet::Pops::Evaluator::Collectors::AbstractCollector)
       # use verbatim - behavior defined by 3x
       target_resource = target
     else
       # transform into the wonderful String representation in 3x
       type, title = Puppet::Pops::Evaluator::Runtime3Converter.instance.catalog_type_to_split_type_title(target)
       target_resource = Puppet::Resource.new(type, title)
     end
     # Add the relationship to the compiler for later evaluation.
     scope.compiler.add_relationship(Puppet::Parser::Relationship.new(source_resource, target_resource, relationship_type))
   end
 
   # Coerce value `v` to numeric or fails.
   # The given value `v` is coerced to Numeric, and if that fails the operation
   # calls {#fail}.
   # @param v [Object] the value to convert
   # @param o [Object] originating instruction
   # @param scope [Object] the (runtime specific) scope where evaluation of o takes place
   # @return [Numeric] value `v` converted to Numeric.
   #
   def coerce_numeric(v, o, scope)
     unless n = Puppet::Pops::Utils.to_n(v)
       fail(Puppet::Pops::Issues::NOT_NUMERIC, o, {:value => v})
     end
     n
   end
 
-  def call_function(name, args, o, scope)
+  def call_function(name, args, o, scope, &block)
     # Call via 4x API if the function exists there
     loaders = scope.compiler.loaders
     # find the loader that loaded the code, or use the private_environment_loader (sees env + all modules)
     adapter = Puppet::Pops::Utils.find_adapter(o, Puppet::Pops::Adapters::LoaderAdapter)
     loader = adapter.nil? ? loaders.private_environment_loader : adapter.loader
     if loader && func = loader.load(:function, name)
-      return func.call(scope, *args)
+      return func.call(scope, *args, &block)
     end
 
     # Call via 3x API if function exists there
     fail(Puppet::Pops::Issues::UNKNOWN_FUNCTION, o, {:name => name}) unless Puppet::Parser::Functions.function(name)
 
     # Arguments must be mapped since functions are unaware of the new and magical creatures in 4x.
     # NOTE: Passing an empty string last converts nil/:undef to empty string
     mapped_args = Puppet::Pops::Evaluator::Runtime3Converter.map_args(args, scope, '')
-    result = scope.send("function_#{name}", mapped_args)
+    result = scope.send("function_#{name}", mapped_args, &block)
     # Prevent non r-value functions from leaking their result (they are not written to care about this)
     Puppet::Parser::Functions.rvalue?(name) ? result : nil
   end
 
   # The o is used for source reference
   def create_resource_parameter(o, scope, name, value, operator)
     file, line = extract_file_line(o)
     Puppet::Parser::Resource::Param.new(
       :name   => name,
       :value  => convert(value, scope, nil), # converted to 3x since 4x supports additional objects / types
       :source => scope.source, :line => line, :file => file,
       :add    => operator == :'+>'
     )
   end
 
   def convert(value, scope, undef_value)
     Puppet::Pops::Evaluator::Runtime3Converter.convert(value, scope, undef_value)
   end
 
   CLASS_STRING = 'class'.freeze
 
   def create_resources(o, scope, virtual, exported, type_name, resource_titles, evaluated_parameters)
 
     # TODO: Unknown resource causes creation of Resource to fail with ArgumentError, should give
     # a proper Issue. Now the result is "Error while evaluating a Resource Statement" with the message
     # from the raised exception. (It may be good enough).
 
     # resolve in scope.
     fully_qualified_type, resource_titles = scope.resolve_type_and_titles(type_name, resource_titles)
 
     # Not 100% accurate as this is the resource expression location and each title is processed separately
     # The titles are however the result of evaluation and they have no location at this point (an array
     # of positions for the source expressions are required for this to work).
     # TODO: Revisit and possible improve the accuracy.
     #
     file, line = extract_file_line(o)
     # Build a resource for each title
     resource_titles.map do |resource_title|
         resource = Puppet::Parser::Resource.new(
           fully_qualified_type, resource_title,
           :parameters => evaluated_parameters,
           :file => file,
           :line => line,
           :exported => exported,
           :virtual => virtual,
           # WTF is this? Which source is this? The file? The name of the context ?
           :source => scope.source,
           :scope => scope,
           :strict => true
         )
 
         if resource.resource_type.is_a? Puppet::Resource::Type
           resource.resource_type.instantiate_resource(scope, resource)
         end
         scope.compiler.add_resource(scope, resource)
         scope.compiler.evaluate_classes([resource_title], scope, false, true) if fully_qualified_type == CLASS_STRING
         # Turn the resource into a PType (a reference to a resource type)
         # weed out nil's
         resource_to_ptype(resource)
     end
   end
 
   # Defines default parameters for a type with the given name.
   #
   def create_resource_defaults(o, scope, type_name, evaluated_parameters)
     # Note that name must be capitalized in this 3x call
     # The 3x impl creates a Resource instance with a bogus title and then asks the created resource
     # for the type of the name.
     # Note, locations are available per parameter.
     #
     scope.define_settings(capitalize_qualified_name(type_name), evaluated_parameters)
   end
 
   # Capitalizes each segment of a qualified name
   #
   def capitalize_qualified_name(name)
     name.split(/::/).map(&:capitalize).join(NAME_SPACE_SEPARATOR)
   end
 
   # Creates resource overrides for all resource type objects in evaluated_resources. The same set of
   # evaluated parameters are applied to all.
   #
   def create_resource_overrides(o, scope, evaluated_resources, evaluated_parameters)
     # Not 100% accurate as this is the resource expression location and each title is processed separately
     # The titles are however the result of evaluation and they have no location at this point (an array
     # of positions for the source expressions are required for this to work.
     # TODO: Revisit and possible improve the accuracy.
     #
     file, line = extract_file_line(o)
 
     evaluated_resources.each do |r|
       unless r.is_a?(Puppet::Pops::Types::PResourceType) && r.type_name != 'class'
         fail(Puppet::Pops::Issues::ILLEGAL_OVERRIDEN_TYPE, o, {:actual => r} )
       end
       resource = Puppet::Parser::Resource.new(
       r.type_name, r.title,
         :parameters => evaluated_parameters,
         :file => file,
         :line => line,
         # WTF is this? Which source is this? The file? The name of the context ?
         :source => scope.source,
         :scope => scope
       )
 
       scope.compiler.add_override(resource)
     end
   end
 
   # Finds a resource given a type and a title.
   #
   def find_resource(scope, type_name, title)
     scope.compiler.findresource(type_name, title)
   end
 
   # Returns the value of a resource's parameter by first looking up the parameter in the resource
   # and then in the defaults for the resource. Since the resource exists (it must in order to look up its
   # parameters, any overrides have already been applied). Defaults are not applied to a resource until it
   # has been finished (which typically has not taken place when this is evaluated; hence the dual lookup).
   #
   def get_resource_parameter_value(scope, resource, parameter_name)
     # This gets the parameter value, or nil (for both valid parameters and parameters that do not exist).
     val = resource[parameter_name]
 
     # Sometimes the resource is a Puppet::Parser::Resource and sometimes it is
     # a Puppet::Resource. The Puppet::Resource case occurs when puppet language
     # is evaluated against an already completed catalog (where all instances of
     # Puppet::Parser::Resource are converted to Puppet::Resource instances).
     # Evaluating against an already completed catalog is really only found in
     # the language specification tests, where the puppet language is used to
     # test itself.
     if resource.is_a?(Puppet::Parser::Resource)
       # The defaults must be looked up in the scope where the resource was created (not in the given
       # scope where the lookup takes place.
       resource_scope = resource.scope
       if val.nil? && resource_scope && defaults = resource_scope.lookupdefaults(resource.type)
         # NOTE: 3x resource keeps defaults as hash using symbol for name as key to Parameter which (again) holds
         # name and value.
         # NOTE: meta parameters that are unset ends up here, and there are no defaults for those encoded
         # in the defaults, they may receive hardcoded defaults later (e.g. 'tag').
         param = defaults[parameter_name.to_sym]
         # Some parameters (meta parameters like 'tag') does not return a param from which the value can be obtained
         # at all times. Instead, they return a nil param until a value has been set.
         val = param.nil? ? nil : param.value
       end
     end
     val
   end
 
   # Returns true, if the given name is the name of a resource parameter.
   #
   def is_parameter_of_resource?(scope, resource, name)
     return false unless name.is_a?(String)
     resource.valid_parameter?(name)
   end
 
   def resource_to_ptype(resource)
     nil if resource.nil?
     # inference returns the meta type since the 3x Resource is an alternate way to describe a type
     type_calculator.infer(resource).type
   end
 
   # This is the same type of "truth" as used in the current Puppet DSL.
   #
   def is_true? o
     # Is the value true?  This allows us to control the definition of truth
     # in one place.
     case o
     # Support :undef since it may come from a 3x structure
     when :undef
       false
     else
       !!o
     end
   end
 
   # Utility method for TrueClass || FalseClass
   # @param x [Object] the object to test if it is instance of TrueClass or FalseClass
   def is_boolean? x
     x.is_a?(TrueClass) || x.is_a?(FalseClass)
   end
 
   def extract_file_line(o)
     source_pos = Puppet::Pops::Utils.find_closest_positioned(o)
     return [nil, -1] unless source_pos
     [source_pos.locator.file, source_pos.line]
   end
 
   def find_closest_positioned(o)
     return nil if o.nil? || o.is_a?(Puppet::Pops::Model::Program)
     o.offset.nil? ? find_closest_positioned(o.eContainer) : Puppet::Pops::Adapters::SourcePosAdapter.adapt(o)
   end
 
   # Creates a diagnostic producer
   def diagnostic_producer
     Puppet::Pops::Validation::DiagnosticProducer.new(
       ExceptionRaisingAcceptor.new(),                   # Raises exception on all issues
       SeverityProducer.new(), # All issues are errors
       Puppet::Pops::Model::ModelLabelProvider.new())
   end
 
   # Configure the severity of failures
   class SeverityProducer < Puppet::Pops::Validation::SeverityProducer
     Issues = Puppet::Pops::Issues
 
     def initialize
       super
       p = self
       # Issues triggering warning only if --debug is on
       if Puppet[:debug]
         p[Issues::EMPTY_RESOURCE_SPECIALIZATION] = :warning
       else
         p[Issues::EMPTY_RESOURCE_SPECIALIZATION] = :ignore
       end
 
       # Store config issues, ignore or warning
       p[Issues::RT_NO_STORECONFIGS_EXPORT]    = Puppet[:storeconfigs] ? :ignore : :warning
       p[Issues::RT_NO_STORECONFIGS]           = Puppet[:storeconfigs] ? :ignore : :warning
     end
   end
 
   # An acceptor of diagnostics that immediately raises an exception.
   class ExceptionRaisingAcceptor < Puppet::Pops::Validation::Acceptor
     def accept(diagnostic)
       super
       Puppet::Pops::IssueReporter.assert_and_report(self, {:message => "Evaluation Error:", :emit_warnings => true })
       if errors?
         raise ArgumentError, "Internal Error: Configuration of runtime error handling wrong: should have raised exception"
       end
     end
   end
 
   class EvaluationError < StandardError
   end
 end
diff --git a/lib/puppet/pops/functions/dispatch.rb b/lib/puppet/pops/functions/dispatch.rb
index 29a58e036..c4b1d8abc 100644
--- a/lib/puppet/pops/functions/dispatch.rb
+++ b/lib/puppet/pops/functions/dispatch.rb
@@ -1,76 +1,80 @@
 # Defines a connection between a implementation method and the signature that
 # the method will handle.
 #
 # This interface should not be used directly. Instead dispatches should be
 # constructed using the DSL defined in {Puppet::Functions}.
 #
 # @api private
 class Puppet::Pops::Functions::Dispatch < Puppet::Pops::Evaluator::CallableSignature
   # @api public
   attr_reader :type
   # TODO: refactor to parameter_names since that makes it API
   attr_reader :param_names
   attr_reader :injections
 
   # Describes how arguments are woven if there are injections, a regular argument is a given arg index, an array
   # an injection description.
   #
   attr_reader :weaving
   # @api public
   attr_reader :block_name
 
   # @api private
   def initialize(type, method_name, param_names, block_name, injections, weaving, last_captures)
     @type = type
     @method_name = method_name
     @param_names = param_names || []
     @block_name = block_name
     @injections = injections || []
     @weaving = weaving
     @last_captures = last_captures
   end
 
   # @api private
   def parameter_names
     @param_names
   end
 
   # @api private
   def last_captures_rest?
     !! @last_captures
   end
 
   # @api private
-  def invoke(instance, calling_scope, args)
-    instance.send(@method_name, *weave(calling_scope, args))
+  def invoke(instance, calling_scope, args, &block)
+    instance.send(@method_name, *weave(calling_scope, args), &block)
   end
 
   # @api private
   def weave(scope, args)
     # no need to weave if there are no injections
-    if injections.empty?
+    if @injections.empty?
       args
     else
       injector = nil # lazy lookup of injector Puppet.lookup(:injector)
-      weaving.map do |knit|
+      new_args = []
+      @weaving.each do |knit|
         if knit.is_a?(Array)
           injection_data = @injections[knit[0]]
-          case injection_data[3]
-          when :dispatcher_internal
-            # currently only supports :scope injection
-            scope
-          when :producer
-            injector ||= Puppet.lookup(:injector)
-            injector.lookup_producer(scope, injection_data[0], injection_data[2])
-          else
-            injector ||= Puppet.lookup(:injector)
-            injector.lookup(scope, injection_data[0], injection_data[2])
-          end
+          new_args <<
+            case injection_data[3]
+            when :dispatcher_internal
+              # currently only supports :scope injection
+              scope
+            when :producer
+              injector ||= Puppet.lookup(:injector)
+              injector.lookup_producer(scope, injection_data[0], injection_data[2])
+            else
+              injector ||= Puppet.lookup(:injector)
+              injector.lookup(scope, injection_data[0], injection_data[2])
+            end
         else
-          # pick that argument (injection of static value)
-          args[knit]
+          # Careful so no new nil arguments are added since they would override default
+          # parameter values in the received
+          new_args << args[knit] if knit < args.size
         end
       end
+      new_args
     end
   end
 end
diff --git a/lib/puppet/pops/functions/dispatcher.rb b/lib/puppet/pops/functions/dispatcher.rb
index f15ad373b..45ea40384 100644
--- a/lib/puppet/pops/functions/dispatcher.rb
+++ b/lib/puppet/pops/functions/dispatcher.rb
@@ -1,70 +1,70 @@
 # Evaluate the dispatches defined as {Puppet::Pops::Functions::Dispatch}
 # instances to call the appropriate method on the
 # {Puppet::Pops::Functions::Function} instance.
 #
 # @api private
 class Puppet::Pops::Functions::Dispatcher
   attr_reader :dispatchers
 
   # @api private
   def initialize()
     @dispatchers = [ ]
   end
 
   # Answers if dispatching has been defined
   # @return [Boolean] true if dispatching has been defined
   #
   # @api private
   def empty?
     @dispatchers.empty?
   end
 
   # Dispatches the call to the first found signature (entry with matching type).
   #
   # @param instance [Puppet::Functions::Function] - the function to call
   # @param calling_scope [T.B.D::Scope] - the scope of the caller
   # @param args [Array<Object>] - the given arguments in the form of an Array
   # @return [Object] - what the called function produced
   #
   # @api private
-  def dispatch(instance, calling_scope, args)
+  def dispatch(instance, calling_scope, args, &block)
     tc = Puppet::Pops::Types::TypeCalculator
-    actual = tc.infer_set(args)
+    actual = tc.infer_set(block_given? ? args + [block] : args)
     found = @dispatchers.find { |d| tc.callable?(d.type, actual) }
     if found
-      found.invoke(instance, calling_scope, args)
+      found.invoke(instance, calling_scope, args, &block)
     else
       raise ArgumentError, "function '#{instance.class.name}' called with mis-matched arguments\n#{Puppet::Pops::Evaluator::CallableMismatchDescriber.diff_string(instance.class.name, actual, @dispatchers)}"
     end
   end
 
   # Adds a regular dispatch for one method name
   #
   # @param type [Puppet::Pops::Types::PArrayType, Puppet::Pops::Types::PTupleType] - type describing signature
   # @param method_name [String] - the name of the method that will be called when type matches given arguments
   # @param names [Array<String>] - array with names matching the number of parameters specified by type (or empty array)
   #
   # @api private
   def add_dispatch(type, method_name, param_names, block_name, injections, weaving, last_captures)
     @dispatchers << Puppet::Pops::Functions::Dispatch.new(type, method_name, param_names, block_name, injections, weaving, last_captures)
   end
 
   # Produces a CallableType for a single signature, and a Variant[<callables>] otherwise
   #
   # @api private
   def to_type()
     # make a copy to make sure it can be contained by someone else (even if it is not contained here, it
     # should be treated as immutable).
     #
     callables = dispatchers.map { | dispatch | dispatch.type.copy }
 
     # multiple signatures, produce a Variant type of Callable1-n (must copy them)
     # single signature, produce single Callable
     callables.size > 1 ?  Puppet::Pops::Types::TypeFactory.variant(*callables) : callables.pop
   end
 
   # @api private
   def signatures
     @dispatchers
   end
 end
diff --git a/lib/puppet/pops/functions/function.rb b/lib/puppet/pops/functions/function.rb
index e30cce030..b16d43a5b 100644
--- a/lib/puppet/pops/functions/function.rb
+++ b/lib/puppet/pops/functions/function.rb
@@ -1,109 +1,109 @@
 # @note WARNING: This new function API is still under development and may change at
 #   any time
 #
 # A function in the puppet evaluator.
 #
 # Functions are normally defined by another system, which produces subclasses
 # of this class as well as constructing delegations to call the appropriate methods.
 #
 # This class should rarely be used directly. Instead functions should be
 # constructed using {Puppet::Functions.create_function}.
 #
 # @api public
 class Puppet::Pops::Functions::Function
   # The scope where the function was defined
   attr_reader :closure_scope
 
   # The loader that loaded this function.
   # Should be used if function wants to load other things.
   #
   attr_reader :loader
 
   def initialize(closure_scope, loader)
     @closure_scope = closure_scope
     @loader = loader
   end
 
   # Invokes the function via the dispatching logic that performs type check and weaving.
   # A specialized function may override this method to do its own dispatching and checking of
   # the raw arguments. A specialized implementation can rearrange arguments, add or remove
   # arguments and then delegate to the dispatching logic by calling:
   #
   # @example Delegating to the dispatcher
   #     def call(scope, *args)
   #       manipulated_args = args + ['easter_egg']
   #       self.class.dispatcher.dispatch(self, scope, manipulated_args)
   #     end
   #
   # System functions that must have access to the calling scope can use this technique. Functions
   # in general should not need the calling scope. (The closure scope; what is visible where the function
   # is defined) is available via the method `closure_scope`).
   #
   # @api public
-  def call(scope, *args)
-    self.class.dispatcher.dispatch(self, scope, args)
+  def call(scope, *args, &block)
+    self.class.dispatcher.dispatch(self, scope, args, &block)
   end
 
   # Allows the implementation of a function to call other functions by name. The callable functions
   # are those visible to the same loader that loaded this function (the calling function). The
   # referenced function is called with the calling functions closure scope as the caller's scope.
   #
   # @param function_name [String] The name of the function
   # @param *args [Object] splat of arguments
   # @return [Object] The result returned by the called function
   #
   # @api public
-  def call_function(function_name, *args)
-    internal_call_function(closure_scope, function_name, args)
+  def call_function(function_name, *args, &block)
+    internal_call_function(closure_scope, function_name, args, &block)
   end
 
   # The dispatcher for the function
   #
   # @api private
   def self.dispatcher
     @dispatcher ||= Puppet::Pops::Functions::Dispatcher.new
   end
 
   # Produces information about parameters in a way that is compatible with Closure
   #
   # @api private
   def self.signatures
     @dispatcher.signatures
   end
 
   protected
 
   # Allows the implementation of a function to call other functions by name and pass the caller
   # scope. The callable functions are those visible to the same loader that loaded this function
   # (the calling function).
   #
   # @param scope [Puppet::Parser::Scope] The caller scope
   # @param function_name [String] The name of the function
   # @param args [Array] array of arguments
   # @return [Object] The result returned by the called function
   #
   # @api public
-  def internal_call_function(scope, function_name, args)
+  def internal_call_function(scope, function_name, args, &block)
 
     the_loader = loader
     raise ArgumentError, "Function #{self.class.name}(): cannot call function '#{function_name}' - no loader specified" unless the_loader
 
     func = the_loader.load(:function, function_name)
-    return func.call(scope, *args) if func
+    return func.call(scope, *args, &block) if func
 
     # Check if a 3x function is present. Raise a generic error if it's not to allow upper layers to fill in the details
     # about where in a puppet manifest this error originates. (Such information is not available here).
     loader_scope = closure_scope
     func_3x = Puppet::Parser::Functions.function(function_name, loader_scope.environment) if loader_scope.is_a?(Puppet::Parser::Scope)
     raise ArgumentError, "Function #{self.class.name}(): cannot call function '#{function_name}' - not found" unless func_3x
 
     # Call via 3x API
     # Arguments must be mapped since functions are unaware of the new and magical creatures in 4x.
     # NOTE: Passing an empty string last converts nil/:undef to empty string
-    result = scope.send(func_3x, Puppet::Pops::Evaluator::Runtime3Converter.map_args(args, loader_scope, ''))
+    result = scope.send(func_3x, Puppet::Pops::Evaluator::Runtime3Converter.map_args(args, loader_scope, ''), &block)
 
     # Prevent non r-value functions from leaking their result (they are not written to care about this)
     Puppet::Parser::Functions.rvalue?(function_name) ? result : nil
   end
 
 end
diff --git a/lib/puppet/pops/types/type_calculator.rb b/lib/puppet/pops/types/type_calculator.rb
index e06244bb8..e4424bd01 100644
--- a/lib/puppet/pops/types/type_calculator.rb
+++ b/lib/puppet/pops/types/type_calculator.rb
@@ -1,1736 +1,1779 @@
 # The TypeCalculator can answer questions about puppet types.
 #
 # The Puppet type system is primarily based on sub-classing. When asking the type calculator to infer types from Ruby in general, it
 # may not provide the wanted answer; it does not for instance take module inclusions and extensions into account. In general the type
 # system should be unsurprising for anyone being exposed to the notion of type. The type `Data` may require a bit more explanation; this
 # is an abstract type that includes all scalar types, as well as Array with an element type compatible with Data, and Hash with key
 # compatible with scalar and elements compatible with Data. Expressed differently; Data is what you typically express using JSON (with
 # the exception that the Puppet type system also includes Pattern (regular expression) as a scalar.
 #
 # Inference
 # ---------
 # The `infer(o)` method infers a Puppet type for scalar Ruby objects, and for Arrays and Hashes.
 # The inference result is instance specific for single typed collections
 # and allows answering questions about its embedded type. It does not however preserve multiple types in
 # a collection, and can thus not answer questions like `[1,a].infer() =~ Array[Integer, String]` since the inference
 # computes the common type Scalar when combining Integer and String.
 #
 # The `infer_generic(o)` method infers a generic Puppet type for scalar Ruby object, Arrays and Hashes.
 # This inference result does not contain instance specific information; e.g. Array[Integer] where the integer
 # range is the generic default. Just `infer` it also combines types into a common type.
 #
 # The `infer_set(o)` method works like `infer` but preserves all type information. It does not do any
 # reduction into common types or ranges. This method of inference is best suited for answering questions
 # about an object being an instance of a type. It correctly answers: `[1,a].infer_set() =~ Array[Integer, String]`
 #
 # The `generalize!(t)` method modifies an instance specific inference result to a generic. The method mutates
 # the given argument. Basically, this removes string instances from String, and range from Integer and Float.
 #
 # Assignability
 # -------------
 # The `assignable?(t1, t2)` method answers if t2 conforms to t1. The type t2 may be an instance, in which case
 # its type is inferred, or a type.
 #
 # Instance?
 # ---------
 # The `instance?(t, o)` method answers if the given object (instance) is an instance that is assignable to the given type.
 #
 # String
 # ------
 # Creates a string representation of a type.
 #
 # Creation of Type instances
 # --------------------------
 # Instance of the classes in the {Puppet::Pops::Types type model} are used to denote a specific type. It is most convenient
 # to use the {Puppet::Pops::Types::TypeFactory TypeFactory} when creating instances.
 #
 # @note
 #   In general, new instances of the wanted type should be created as they are assigned to models using containment, and a
 #   contained object can only be in one container at a time. Also, the type system may include more details in each type
 #   instance, such as if it may be nil, be empty, contain a certain count etc. Or put differently, the puppet types are not
 #   singletons.
 #
 # All types support `copy` which should be used when assigning a type where it is unknown if it is bound or not
 # to a parent type. A check can be made with `t.eContainer().nil?`
 #
 # Equality and Hash
 # -----------------
 # Type instances are equal in terms of Ruby eql? and `==` if they describe the same type, but they are not `equal?` if they are not
 # the same type instance. Two types that describe the same type have identical hash - this makes them usable as hash keys.
 #
 # Types and Subclasses
 # --------------------
 # In general, the type calculator should be used to answer questions if a type is a subtype of another (using {#assignable?}, or
 # {#instance?} if the question is if a given object is an instance of a given type (or is a subtype thereof).
 # Many of the types also have a Ruby subtype relationship; e.g. PHashType and PArrayType are both subtypes of PCollectionType, and
 # PIntegerType, PFloatType, PStringType,... are subtypes of PScalarType. Even if it is possible to answer certain questions about
 # type by looking at the Ruby class of the types this is considered an implementation detail, and such checks should in general
 # be performed by the type_calculator which implements the type system semantics.
 #
 # The PRuntimeType
 # -------------
 # The PRuntimeType corresponds to a type in the runtime system (currently only supported runtime is 'ruby'). The
 # type has a runtime_type_name that corresponds to a Ruby Class name.
 # A Runtime[ruby] type can be used to describe any ruby class except for the puppet types that are specialized
 # (i.e. PRuntimeType should not be used for Integer, String, etc. since there are specialized types for those).
 # When the type calculator deals with PRuntimeTypes and checks for assignability, it determines the
 # "common ancestor class" of two classes.
 # This check is made based on the superclasses of the two classes being compared. In order to perform this, the
 # classes must be present (i.e. they are resolved from the string form in the PRuntimeType to a
 # loaded, instantiated Ruby Class). In general this is not a problem, since the question to produce the common
 # super type for two objects means that the classes must be present or there would have been
 # no instances present in the first place. If however the classes are not present, the type
 # calculator will fall back and state that the two types at least have Any in common.
 #
 # @see Puppet::Pops::Types::TypeFactory TypeFactory for how to create instances of types
 # @see Puppet::Pops::Types::TypeParser TypeParser how to construct a type instance from a String
 # @see Puppet::Pops::Types Types for details about the type model
 #
 # Using the Type Calculator
 # -----
 # The type calculator can be directly used via its class methods. If doing time critical work and doing many
 # calls to the type calculator, it is more performant to create an instance and invoke the corresponding
 # instance methods. Note that inference is an expensive operation, rather than inferring the same thing
 # several times, it is in general better to infer once and then copy the result if mutation to a more generic form is
 # required.
 #
 # @api public
 #
 class Puppet::Pops::Types::TypeCalculator
 
   Types = Puppet::Pops::Types
   TheInfinity = 1.0 / 0.0 # because the Infinity symbol is not defined
 
   # @api public
   def self.assignable?(t1, t2)
     singleton.assignable?(t1,t2)
   end
 
   # Answers, does the given callable accept the arguments given in args (an array or a tuple)
   # @param callable [Puppet::Pops::Types::PCallableType] - the callable
   # @param args [Puppet::Pops::Types::PArrayType, Puppet::Pops::Types::PTupleType] args optionally including a lambda callable at the end
   # @return [Boolan] true if the callable accepts the arguments
   #
   # @api public
   def self.callable?(callable, args)
     singleton.callable?(callable, args)
   end
 
   # Produces a String representation of the given type.
   # @param t [Puppet::Pops::Types::PAnyType] the type to produce a string form
   # @return [String] the type in string form
   #
   # @api public
   #
   def self.string(t)
     singleton.string(t)
   end
 
   # @api public
   def self.infer(o)
     singleton.infer(o)
   end
 
   # @api public
   def self.generalize!(o)
     singleton.generalize!(o)
   end
 
   # @api public
   def self.infer_set(o)
     singleton.infer_set(o)
   end
 
   # @api public
   def self.debug_string(t)
     singleton.debug_string(t)
   end
 
   # @api public
   def self.enumerable(t)
     singleton.enumerable(t)
   end
 
   # @api private
   def self.singleton()
     @tc_instance ||= new
   end
 
   # @api public
   #
   def initialize
     @@assignable_visitor ||= Puppet::Pops::Visitor.new(nil,"assignable",1,1)
     @@infer_visitor ||= Puppet::Pops::Visitor.new(nil,"infer",0,0)
     @@infer_set_visitor ||= Puppet::Pops::Visitor.new(nil,"infer_set",0,0)
     @@instance_of_visitor ||= Puppet::Pops::Visitor.new(nil,"instance_of",1,1)
     @@string_visitor ||= Puppet::Pops::Visitor.new(nil,"string",0,0)
     @@inspect_visitor ||= Puppet::Pops::Visitor.new(nil,"debug_string",0,0)
     @@enumerable_visitor ||= Puppet::Pops::Visitor.new(nil,"enumerable",0,0)
     @@extract_visitor ||= Puppet::Pops::Visitor.new(nil,"extract",0,0)
     @@generalize_visitor ||= Puppet::Pops::Visitor.new(nil,"generalize",0,0)
     @@callable_visitor ||= Puppet::Pops::Visitor.new(nil,"callable",1,1)
 
     da = Types::PArrayType.new()
     da.element_type = Types::PDataType.new()
     @data_array = da
 
     h = Types::PHashType.new()
     h.element_type = Types::PDataType.new()
     h.key_type = Types::PScalarType.new()
     @data_hash = h
 
     @data_t = Types::PDataType.new()
     @scalar_t = Types::PScalarType.new()
     @numeric_t = Types::PNumericType.new()
     @t = Types::PAnyType.new()
 
     # Data accepts a Tuple that has 0-infinity Data compatible entries (e.g. a Tuple equivalent to Array).
     data_tuple = Types::PTupleType.new()
     data_tuple.addTypes(Types::PDataType.new())
     data_tuple.size_type = Types::PIntegerType.new()
     data_tuple.size_type.from = 0
     data_tuple.size_type.to = nil # infinity
     @data_tuple_t = data_tuple
 
     # Variant type compatible with Data
     data_variant = Types::PVariantType.new()
     data_variant.addTypes(@data_hash.copy)
     data_variant.addTypes(@data_array.copy)
     data_variant.addTypes(Types::PScalarType.new)
     data_variant.addTypes(Types::PNilType.new)
     data_variant.addTypes(@data_tuple_t.copy)
     @data_variant_t = data_variant
 
     collection_default_size = Types::PIntegerType.new()
     collection_default_size.from = 0
     collection_default_size.to = nil # infinity
     @collection_default_size_t = collection_default_size
 
     non_empty_string = Types::PStringType.new
     non_empty_string.size_type = Types::PIntegerType.new()
     non_empty_string.size_type.from = 1
     non_empty_string.size_type.to = nil # infinity
     @non_empty_string_t = non_empty_string
 
     @nil_t = Types::PNilType.new
   end
 
   # Convenience method to get a data type for comparisons
   # @api private the returned value may not be contained in another element
   #
   def data
     @data_t
   end
 
   # Convenience method to get a variant compatible with the Data type.
   # @api private the returned value may not be contained in another element
   #
   def data_variant
     @data_variant_t
   end
 
   def self.data_variant
     singleton.data_variant
   end
 
   # Answers the question 'is it possible to inject an instance of the given class'
   # A class is injectable if it has a special *assisted inject* class method called `inject` taking
   # an injector and a scope as argument, or if it has a zero args `initialize` method.
   #
   # @param klazz [Class, PRuntimeType] the class/type to check if it is injectable
   # @return [Class, nil] the injectable Class, or nil if not injectable
   # @api public
   #
   def injectable_class(klazz)
     # Handle case when we get a PType instead of a class
     if klazz.is_a?(Types::PRuntimeType)
       klazz = Puppet::Pops::Types::ClassLoader.provide(klazz)
     end
 
     # data types can not be injected (check again, it is not safe to assume that given RubyRuntime klazz arg was ok)
     return false unless type(klazz).is_a?(Types::PRuntimeType)
     if (klazz.respond_to?(:inject) && klazz.method(:inject).arity() == -4) || klazz.instance_method(:initialize).arity() == 0
       klazz
     else
       nil
     end
   end
 
   # Answers 'can an instance of type t2 be assigned to a variable of type t'.
   # Does not accept nil/undef unless the type accepts it.
   #
   # @api public
   #
   def assignable?(t, t2)
     if t.is_a?(Class)
       t = type(t)
     end
 
     if t2.is_a?(Class)
       t2 = type(t2)
     end
     # Unit can be assigned to anything
     return true if t2.class == Types::PUnitType
 
     if t2.class == Types::PVariantType
       # Assignable if all contained types are assignable
       t2.types.all? { |vt| @@assignable_visitor.visit_this_1(self, t, vt) }
     else
       @@assignable_visitor.visit_this_1(self, t, t2)
     end
  end
 
   # Returns an enumerable if the t represents something that can be iterated
   def enumerable(t)
     @@enumerable_visitor.visit_this_0(self, t)
   end
 
   # Answers, does the given callable accept the arguments given in args (an array or a tuple)
   #
   def callable?(callable, args)
     return false if !self.class.is_kind_of_callable?(callable)
     # Note that polymorphism is for the args type, the callable is always a callable
     @@callable_visitor.visit_this_1(self, args, callable)
   end
 
   # Answers if the two given types describe the same type
   def equals(left, right)
     return false unless left.is_a?(Types::PAnyType) && right.is_a?(Types::PAnyType)
     # Types compare per class only - an extra test must be made if the are mutually assignable
     # to find all types that represent the same type of instance
     #
     left == right || (assignable?(right, left) && assignable?(left, right))
   end
 
   # Answers 'what is the Puppet Type corresponding to the given Ruby class'
   # @param c [Class] the class for which a puppet type is wanted
   # @api public
   #
   def type(c)
     raise ArgumentError, "Argument must be a Class" unless c.is_a? Class
 
     # Can't use a visitor here since we don't have an instance of the class
     case
     when c <= Integer
       type = Types::PIntegerType.new()
     when c == Float
       type = Types::PFloatType.new()
     when c == Numeric
       type = Types::PNumericType.new()
     when c == String
       type = Types::PStringType.new()
     when c == Regexp
       type = Types::PRegexpType.new()
     when c == NilClass
       type = Types::PNilType.new()
     when c == FalseClass, c == TrueClass
       type = Types::PBooleanType.new()
     when c == Class
       type = Types::PType.new()
     when c == Array
       # Assume array of data values
       type = Types::PArrayType.new()
       type.element_type = Types::PDataType.new()
     when c == Hash
       # Assume hash with scalar keys and data values
       type = Types::PHashType.new()
       type.key_type = Types::PScalarType.new()
       type.element_type = Types::PDataType.new()
     else
       type = Types::PRuntimeType.new(:runtime => :ruby, :runtime_type_name => c.name)
     end
     type
   end
 
   # Generalizes value specific types. The given type is mutated and returned.
   # @api public
   def generalize!(o)
     @@generalize_visitor.visit_this_0(self, o)
     o.eAllContents.each { |x| @@generalize_visitor.visit_this_0(self, x) }
     o
   end
 
   def generalize_Object(o)
     # do nothing, there is nothing to change for most types
   end
 
   def generalize_PStringType(o)
     o.values = []
     o.size_type = nil
     []
   end
 
   def generalize_PCollectionType(o)
     # erase the size constraint from Array and Hash (if one exists, it is transformed to -Infinity - + Infinity, which is
     # not desirable.
     o.size_type = nil
   end
 
   def generalize_PFloatType(o)
     o.to = nil
     o.from = nil
   end
 
   def generalize_PIntegerType(o)
     o.to = nil
     o.from = nil
   end
 
   # Answers 'what is the single common Puppet Type describing o', or if o is an Array or Hash, what is the
   # single common type of the elements (or keys and elements for a Hash).
   # @api public
   #
   def infer(o)
     @@infer_visitor.visit_this_0(self, o)
   end
 
   def infer_generic(o)
     result = generalize!(infer(o))
     result
   end
 
   # Answers 'what is the set of Puppet Types of o'
   # @api public
   #
   def infer_set(o)
     @@infer_set_visitor.visit_this_0(self, o)
   end
 
   def instance_of(t, o)
     @@instance_of_visitor.visit_this_1(self, t, o)
   end
 
   def instance_of_Object(t, o)
     # Undef is Undef and Any, but nothing else when checking instance?
     return false if (o.nil?) && t.class != Types::PAnyType
     assignable?(t, infer(o))
   end
 
   # Anything is an instance of Unit
   # @api private
   def instance_of_PUnitType(t, o)
     true
   end
 
   def instance_of_PArrayType(t, o)
     return false unless o.is_a?(Array)
     return false unless o.all? {|element| instance_of(t.element_type, element) }
     size_t = t.size_type || @collection_default_size_t
     # optimize by calling directly
     return instance_of_PIntegerType(size_t, o.size)
   end
 
   # @api private
   def instance_of_PIntegerType(t, o)
     return false unless o.is_a?(Integer)
     x = t.from
     x = -Float::INFINITY if x.nil? || x == :default
     y = t.to
     y = Float::INFINITY if y.nil? || y == :default
     return x < y ? x <= o && y >= o : y <= o && x >= o
   end
 
   # @api private
   def instance_of_PStringType(t, o)
     return false unless o.is_a?(String)
     # true if size compliant
     size_t = t.size_type || @collection_default_size_t
     instance_of_PIntegerType(size_t, o.size)
   end
 
   def instance_of_PTupleType(t, o)
     return false unless o.is_a?(Array)
     # compute the tuple's min/max size, and check if that size matches
     size_t = t.size_type || Puppet::Pops::Types::TypeFactory.range(*t.size_range)
 
     return false unless instance_of_PIntegerType(size_t, o.size)
     o.each_with_index do |element, index|
        return false unless instance_of(t.types[index] || t.types[-1], element)
     end
     true
   end
 
   def instance_of_PStructType(t, o)
     return false unless o.is_a?(Hash)
     h = t.hashed_elements
     # all keys must be present and have a value (even if nil/undef)
     (o.keys - h.keys).empty? && h.all? { |k,v| instance_of(v, o[k]) }
   end
 
   def instance_of_PHashType(t, o)
     return false unless o.is_a?(Hash)
     key_t = t.key_type
     element_t = t.element_type
     return false unless o.keys.all? {|key| instance_of(key_t, key) } && o.values.all? {|value| instance_of(element_t, value) }
     size_t = t.size_type || @collection_default_size_t
     # optimize by calling directly
     return instance_of_PIntegerType(size_t, o.size)
   end
 
   def instance_of_PDataType(t, o)
     instance_of(@data_variant_t, o)
   end
 
   def instance_of_PNilType(t, o)
     o.nil? || o == :undef
   end
 
   def instance_of_POptionalType(t, o)
     instance_of_PNilType(t, o) || instance_of(t.optional_type, o)
   end
 
   def instance_of_PVariantType(t, o)
     # instance of variant if o is instance? of any of variant's types
     t.types.any? { |option_t| instance_of(option_t, o) }
   end
 
   # Answers 'is o an instance of type t'
   # @api public
   #
   def self.instance?(t, o)
     singleton.instance_of(t,o)
   end
 
   # Answers 'is o an instance of type t'
   # @api public
   #
   def instance?(t, o)
     instance_of(t,o)
   end
 
   # Answers if t is a puppet type
   # @api public
   #
   def is_ptype?(t)
     return t.is_a?(Types::PAnyType)
   end
 
   # Answers if t represents the puppet type PNilType
   # @api public
   #
   def is_pnil?(t)
     return t.nil? || t.is_a?(Types::PNilType)
   end
 
   # Answers, 'What is the common type of t1 and t2?'
   #
   # TODO: The current implementation should be optimized for performance
   #
   # @api public
   #
   def common_type(t1, t2)
     raise ArgumentError, 'two types expected' unless (is_ptype?(t1) || is_pnil?(t1)) && (is_ptype?(t2) || is_pnil?(t2))
 
     # TODO: This is not right since Scalar U Undef is Any
     # if either is nil, the common type is the other
     if is_pnil?(t1)
       return t2
     elsif is_pnil?(t2)
       return t1
     end
 
     # If either side is Unit, it is the other type
     if t1.is_a?(Types::PUnitType)
       return t2
     elsif t2.is_a?(Types::PUnitType)
       return t1
     end
 
     # Simple case, one is assignable to the other
     if assignable?(t1, t2)
       return t1
     elsif assignable?(t2, t1)
       return t2
     end
 
     # when both are arrays, return an array with common element type
     if t1.is_a?(Types::PArrayType) && t2.is_a?(Types::PArrayType)
       type = Types::PArrayType.new()
       type.element_type = common_type(t1.element_type, t2.element_type)
       return type
     end
 
     # when both are hashes, return a hash with common key- and element type
     if t1.is_a?(Types::PHashType) && t2.is_a?(Types::PHashType)
       type = Types::PHashType.new()
       type.key_type = common_type(t1.key_type, t2.key_type)
       type.element_type = common_type(t1.element_type, t2.element_type)
       return type
     end
 
     # when both are host-classes, reduce to PHostClass[] (since one was not assignable to the other)
     if t1.is_a?(Types::PHostClassType) && t2.is_a?(Types::PHostClassType)
       return Types::PHostClassType.new()
     end
 
     # when both are resources, reduce to Resource[T] or Resource[] (since one was not assignable to the other)
     if t1.is_a?(Types::PResourceType) && t2.is_a?(Types::PResourceType)
       result = Types::PResourceType.new()
       # only Resource[] unless the type name is the same
       if t1.type_name == t2.type_name then result.type_name = t1.type_name end
       # the cross assignability test above has already determined that they do not have the same type and title
       return result
     end
 
     # Integers have range, expand the range to the common range
     if t1.is_a?(Types::PIntegerType) && t2.is_a?(Types::PIntegerType)
       t1range = from_to_ordered(t1.from, t1.to)
       t2range = from_to_ordered(t2.from, t2.to)
       t = Types::PIntegerType.new()
       from = [t1range[0], t2range[0]].min
       to = [t1range[1], t2range[1]].max
       t.from = from unless from == TheInfinity
       t.to = to unless to == TheInfinity
       return t
     end
 
     # Floats have range, expand the range to the common range
     if t1.is_a?(Types::PFloatType) && t2.is_a?(Types::PFloatType)
       t1range = from_to_ordered(t1.from, t1.to)
       t2range = from_to_ordered(t2.from, t2.to)
       t = Types::PFloatType.new()
       from = [t1range[0], t2range[0]].min
       to = [t1range[1], t2range[1]].max
       t.from = from unless from == TheInfinity
       t.to = to unless to == TheInfinity
       return t
     end
 
     if t1.is_a?(Types::PStringType) && t2.is_a?(Types::PStringType)
       t = Types::PStringType.new()
       t.values = t1.values | t2.values
       return t
     end
 
     if t1.is_a?(Types::PPatternType) && t2.is_a?(Types::PPatternType)
       t = Types::PPatternType.new()
       # must make copies since patterns are contained types, not data-types
       t.patterns = (t1.patterns | t2.patterns).map(&:copy)
       return t
     end
 
     if t1.is_a?(Types::PEnumType) && t2.is_a?(Types::PEnumType)
       # The common type is one that complies with either set
       t = Types::PEnumType.new
       t.values = t1.values | t2.values
       return t
     end
 
     if t1.is_a?(Types::PVariantType) && t2.is_a?(Types::PVariantType)
       # The common type is one that complies with either set
       t = Types::PVariantType.new
       t.types = (t1.types | t2.types).map(&:copy)
       return t
     end
 
     if t1.is_a?(Types::PRegexpType) && t2.is_a?(Types::PRegexpType)
       # if they were identical, the general rule would return a parameterized regexp
       # since they were not, the result is a generic regexp type
       return Types::PPatternType.new()
     end
 
     if t1.is_a?(Types::PCallableType) && t2.is_a?(Types::PCallableType)
       # They do not have the same signature, and one is not assignable to the other,
       # what remains is the most general form of Callable
       return Types::PCallableType.new()
     end
 
     # Common abstract types, from most specific to most general
     if common_numeric?(t1, t2)
       return Types::PNumericType.new()
     end
 
     if common_scalar?(t1, t2)
       return Types::PScalarType.new()
     end
 
     if common_data?(t1,t2)
       return Types::PDataType.new()
     end
 
     # Meta types Type[Integer] + Type[String] => Type[Data]
     if t1.is_a?(Types::PType) && t2.is_a?(Types::PType)
       type = Types::PType.new()
       type.type = common_type(t1.type, t2.type)
       return type
     end
 
     # If both are Runtime types
     if t1.is_a?(Types::PRuntimeType) && t2.is_a?(Types::PRuntimeType)
       if t1.runtime == t2.runtime && t1.runtime_type_name == t2.runtime_type_name
         return t1
       end
       # finding the common super class requires that names are resolved to class
       # NOTE: This only supports runtime type of :ruby
       c1 = Types::ClassLoader.provide_from_type(t1)
       c2 = Types::ClassLoader.provide_from_type(t2)
       if c1 && c2
         c2_superclasses = superclasses(c2)
         superclasses(c1).each do|c1_super|
           c2_superclasses.each do |c2_super|
             if c1_super == c2_super
               return Types::PRuntimeType.new(:runtime => :ruby, :runtime_type_name => c1_super.name)
             end
           end
         end
       end
     end
 
     # They better both be Any type, or the wrong thing was asked and nil is returned
     if t1.is_a?(Types::PAnyType) && t2.is_a?(Types::PAnyType)
       return Types::PAnyType.new()
     end
   end
 
   # Produces the superclasses of the given class, including the class
   def superclasses(c)
     result = [c]
     while s = c.superclass
       result << s
       c = s
     end
     result
   end
 
   # Produces a string representing the type
   # @api public
   #
   def string(t)
     @@string_visitor.visit_this_0(self, t)
   end
 
   # Produces a debug string representing the type (possibly with more information that the regular string format)
   # @api public
   #
   def debug_string(t)
     @@inspect_visitor.visit_this_0(self, t)
   end
 
 
   # Reduces an enumerable of types to a single common type.
   # @api public
   #
   def reduce_type(enumerable)
     enumerable.reduce(nil) {|memo, t| common_type(memo, t) }
   end
 
   # Reduce an enumerable of objects to a single common type
   # @api public
   #
   def infer_and_reduce_type(enumerable)
     reduce_type(enumerable.collect() {|o| infer(o) })
   end
 
   # The type of all classes is PType
   # @api private
   #
   def infer_Class(o)
     Types::PType.new()
   end
 
   # @api private
   def infer_Closure(o)
     o.type()
   end
 
   # @api private
   def infer_Function(o)
     o.class.dispatcher.to_type
   end
 
   # @api private
   def infer_Object(o)
     Types::PRuntimeType.new(:runtime => :ruby, :runtime_type_name => o.class.name)
   end
 
   # The type of all types is PType
   # @api private
   #
   def infer_PAnyType(o)
     type = Types::PType.new()
     type.type = o.copy
     type
   end
 
   # The type of all types is PType
   # This is the metatype short circuit.
   # @api private
   #
   def infer_PType(o)
     type = Types::PType.new()
     type.type = o.copy
     type
   end
 
   # @api private
   def infer_String(o)
     t = Types::PStringType.new()
     t.addValues(o)
     t.size_type = size_as_type(o)
     t
   end
 
   # @api private
   def infer_Float(o)
     t = Types::PFloatType.new()
     t.from = o
     t.to = o
     t
   end
 
   # @api private
   def infer_Integer(o)
     t = Types::PIntegerType.new()
     t.from = o
     t.to = o
     t
   end
 
   # @api private
   def infer_Regexp(o)
     t = Types::PRegexpType.new()
     t.pattern = o.source
     t
   end
 
   # @api private
   def infer_NilClass(o)
     Types::PNilType.new()
   end
 
+  # @api private
+  # @param o [Proc]
+  def infer_Proc(o)
+    min = 0
+    max = 0
+    if o.respond_to?(:parameters)
+      mapped_types = o.parameters.map do |p|
+        param_t = Types::PAnyType.new
+        case p[0]
+        when :rest
+          max = :default
+          break param_t
+        when :req
+          min += 1
+        end
+        max += 1
+      	param_t
+      end
+    else
+      # Cannot correctly compute the signature in Ruby 1.8.7 because arity for
+      # optional values is screwed up (there is no way to get the upper limit),
+      # an optional looks the same as a varargs.
+      arity = o.arity
+      if arity < 0
+        min = -arity - 1
+        max = :default # i.e. infinite (which is wrong when there are optional - flaw in 1.8.7)
+      else
+        min = max = arity
+      end
+      mapped_types = Array.new(min) { Types::PAnyType.new }
+    end
+    if min == 0 || min != max
+      mapped_types << min
+      mapped_types << max
+    end
+    Types::TypeFactory.callable(*mapped_types)
+  end
+
+  # @api private
+  def infer_PuppetProc(o)
+    infer_Closure(o.closure)
+  end
+
   # Inference of :default as PDefaultType, and all other are Ruby[Symbol]
   # @api private
   def infer_Symbol(o)
     case o
     when :default
       Types::PDefaultType.new()
     else
       infer_Object(o)
     end
   end
 
   # @api private
   def infer_TrueClass(o)
     Types::PBooleanType.new()
   end
 
   # @api private
   def infer_FalseClass(o)
     Types::PBooleanType.new()
   end
 
   # @api private
   # A Puppet::Parser::Resource, or Puppet::Resource
   #
   def infer_Resource(o)
     t = Types::PResourceType.new()
     t.type_name = o.type.to_s.downcase
     # Only Puppet::Resource can have a title that is a symbol :undef, a PResource cannot.
     # A mapping must be made to empty string. A nil value will result in an error later
     title = o.title
     t.title = (:undef == title  ? '' : title)
     type = Types::PType.new()
     type.type = t
     type
   end
 
   # @api private
   def infer_Array(o)
     type = Types::PArrayType.new()
     type.element_type =
     if o.empty?
       Types::PNilType.new()
     else
       infer_and_reduce_type(o)
     end
     type.size_type = size_as_type(o)
     type
   end
 
   # @api private
   def infer_Hash(o)
     type = Types::PHashType.new()
     if o.empty?
       ktype = Types::PNilType.new()
       etype = Types::PNilType.new()
     else
       ktype = infer_and_reduce_type(o.keys())
       etype = infer_and_reduce_type(o.values())
     end
     type.key_type = ktype
     type.element_type = etype
     type.size_type = size_as_type(o)
     type
   end
 
   def size_as_type(collection)
     size = collection.size
     t = Types::PIntegerType.new()
     t.from = size
     t.to = size
     t
   end
 
   # Common case for everything that intrinsically only has a single type
   def infer_set_Object(o)
     infer(o)
   end
 
   def infer_set_Array(o)
     if o.empty?
       type = Types::PArrayType.new()
       type.element_type = Types::PNilType.new()
       type.size_type = size_as_type(o)
     else
       type = Types::PTupleType.new()
       type.types = o.map() {|x| infer_set(x) }
     end
     type
   end
 
   def infer_set_Hash(o)
     if o.empty?
       type = Types::PHashType.new
       type.key_type = Types::PNilType.new
       type.element_type = Types::PNilType.new
       type.size_type = size_as_type(o)
     else
       if o.keys.find {|k| !instance_of_PStringType(@non_empty_string_t, k) }
         type = Types::PHashType.new
         ktype = Types::PVariantType.new
         ktype.types = o.keys.map {|k| infer_set(k) }
         etype = Types::PVariantType.new
         etype.types = o.values.map {|e| infer_set(e) }
         type.key_type = unwrap_single_variant(ktype)
         type.element_type = unwrap_single_variant(etype)
         type.size_type = size_as_type(o)
       else
         elements = []
         o.each_pair do |k,v|
           element = Types::PStructElement.new
           element.name = k
           element.type = infer_set(v)
           elements << element
         end
         type = Types::PStructType.new
         type.elements = elements
       end
     end
     type
   end
 
   def unwrap_single_variant(possible_variant)
     if possible_variant.is_a?(Types::PVariantType) && possible_variant.types.size == 1
       possible_variant.types[0]
     else
       possible_variant
     end
   end
 
   # False in general type calculator
   # @api private
   def assignable_Object(t, t2)
     false
   end
 
   # @api private
   def assignable_PAnyType(t, t2)
     t2.is_a?(Types::PAnyType)
   end
 
   # @api private
   def assignable_PNilType(t, t2)
     # Only undef/nil is assignable to nil type
     t2.is_a?(Types::PNilType)
   end
 
   # Anything is assignable to a Unit type
   # @api private
   def assignable_PUnitType(t, t2)
     true
   end
 
   # @api private
   def assignable_PDefaultType(t, t2)
     # Only default is assignable to default type
     t2.is_a?(Types::PDefaultType)
   end
 
   # @api private
   def assignable_PScalarType(t, t2)
     t2.is_a?(Types::PScalarType)
   end
 
   # @api private
   def assignable_PNumericType(t, t2)
     t2.is_a?(Types::PNumericType)
   end
 
   # @api private
   def assignable_PIntegerType(t, t2)
     return false unless t2.is_a?(Types::PIntegerType)
     trange =  from_to_ordered(t.from, t.to)
     t2range = from_to_ordered(t2.from, t2.to)
     # If t2 min and max are within the range of t
     trange[0] <= t2range[0] && trange[1] >= t2range[1]
   end
 
   # Transform int range to a size constraint
   # if range == nil the constraint is 1,1
   # if range.from == nil min size = 1
   # if range.to == nil max size == Infinity
   #
   def size_range(range)
     return [1,1] if range.nil?
     from = range.from
     to = range.to
     x = from.nil? ? 1 : from
     y = to.nil? ? TheInfinity : to
     if x < y
       [x, y]
     else
       [y, x]
     end
   end
 
   # @api private
   def from_to_ordered(from, to)
     x = (from.nil? || from == :default) ? -TheInfinity : from
     y = (to.nil? || to == :default) ? TheInfinity : to
     if x < y
       [x, y]
     else
       [y, x]
     end
   end
 
   # @api private
   def assignable_PVariantType(t, t2)
     # Data is a specific variant
     t2 = @data_variant_t if t2.is_a?(Types::PDataType)
     if t2.is_a?(Types::PVariantType)
       # A variant is assignable if all of its options are assignable to one of this type's options
       return true if t == t2
       t2.types.all? do |other|
         # if the other is a Variant, all of its options, but be assignable to one of this type's options
         other = other.is_a?(Types::PDataType) ? @data_variant_t : other
         if other.is_a?(Types::PVariantType)
           assignable?(t, other)
         else
           t.types.any? {|option_t| assignable?(option_t, other) }
         end
       end
     else
       # A variant is assignable if t2 is assignable to any of its types
       t.types.any? { |option_t| assignable?(option_t, t2) }
     end
   end
 
   # Catch all not callable combinations
   def callable_Object(o, callable_t)
     false
   end
 
   def callable_PTupleType(args_tuple, callable_t)
     if args_tuple.size_type
       raise ArgumentError, "Callable tuple may not have a size constraint when used as args"
     end
     # Assume no block was given - i.e. it is nil, and its type is PNilType
     block_t = @nil_t
     if self.class.is_kind_of_callable?(args_tuple.types.last)
       # a split is needed to make it possible to use required, optional, and varargs semantics
       # of the tuple type.
       #
       args_tuple = args_tuple.copy
       # to drop the callable, it must be removed explicitly since this is an rgen array
       args_tuple.removeTypes(block_t = args_tuple.types.last())
     else
       # no block was given, if it is required, the below will fail
     end
     # unless argument types match parameter types
     return false unless assignable?(callable_t.param_types, args_tuple)
     # can the given block be *called* with a signature requirement specified by callable_t?
     assignable?(callable_t.block_type || @nil_t, block_t)
   end
 
   # @api private
   def self.is_kind_of_callable?(t, optional = true)
     case t
     when Types::PCallableType
       true
     when Types::POptionalType
       optional && is_kind_of_callable?(t.optional_type, optional)
     when Types::PVariantType
       t.types.all? {|t2| is_kind_of_callable?(t2, optional) }
     else
       false
     end
   end
 
 
   def callable_PArrayType(args_array, callable_t)
     return false unless assignable?(callable_t.param_types, args_array)
     # does not support calling with a block, but have to check that callable is ok with missing block
     assignable?(callable_t.block_type || @nil_t, @nil_t)
   end
 
   def callable_PNilType(nil_t, callable_t)
     # if callable_t is Optional (or indeed PNilType), this means that 'missing callable' is accepted
     assignable?(callable_t, nil_t)
   end
 
   def callable_PCallableType(given_callable_t, required_callable_t)
     # If the required callable is euqal or more specific than the given, the given is callable
     assignable?(required_callable_t, given_callable_t)
   end
 
   def max(a,b)
     a >=b ? a : b
   end
 
   def min(a,b)
     a <= b ? a : b
   end
 
   def assignable_PTupleType(t, t2)
     return true if t == t2 || t.types.empty? && (t2.is_a?(Types::PArrayType))
     size_t = t.size_type || Puppet::Pops::Types::TypeFactory.range(*t.size_range)
 
     if t2.is_a?(Types::PTupleType)
       size_t2 = t2.size_type || Puppet::Pops::Types::TypeFactory.range(*t2.size_range)
 
       # not assignable if the number of types in t2 is outside number of types in t1
       if assignable?(size_t, size_t2)
         t2.types.size.times do |index|
           return false unless assignable?((t.types[index] || t.types[-1]), t2.types[index])
         end
         return true
       else
         return false
       end
     elsif t2.is_a?(Types::PArrayType)
       t2_entry = t2.element_type
 
       # Array of anything can not be assigned (unless tuple is tuple of anything) - this case
       # was handled at the top of this method.
       #
       return false if t2_entry.nil?
       size_t = t.size_type || Puppet::Pops::Types::TypeFactory.range(*t.size_range)
       size_t2 = t2.size_type || @collection_default_size_t
       return false unless assignable?(size_t, size_t2)
       min(t.types.size, size_t2.range()[1]).times do |index|
         return false unless assignable?((t.types[index] || t.types[-1]), t2_entry)
       end
       true
     else
       false
     end
   end
 
   # Produces the tuple entry at the given index given a tuple type, its from/to constraints on the last
   # type, and an index.
   # Produces nil if the index is out of bounds
   # from must be less than to, and from may not be less than 0
   #
   # @api private
   #
   def tuple_entry_at(tuple_t, from, to, index)
     regular = (tuple_t.types.size - 1)
     if index < regular
       tuple_t.types[index]
     elsif index < regular + to
       # in the varargs part
       tuple_t.types[-1]
     else
       nil
     end
   end
 
   # @api private
   #
   def assignable_PStructType(t, t2)
     return true if t == t2 || t.elements.empty? && (t2.is_a?(Types::PHashType))
     h = t.hashed_elements
     if t2.is_a?(Types::PStructType)
       h2 = t2.hashed_elements
       h.size == h2.size && h.all? {|k, v| assignable?(v, h2[k]) }
     elsif t2.is_a?(Types::PHashType)
       size_t2 = t2.size_type || @collection_default_size_t
       size_t = Types::PIntegerType.new
       size_t.from = size_t.to = h.size
       # compatible size
       # hash key type must be string of min 1 size
       # hash value t must be assignable to each key
       element_type = t2.element_type
       assignable_PIntegerType(size_t, size_t2) &&
         assignable?(@non_empty_string_t, t2.key_type) &&
         h.all? {|k,v| assignable?(v, element_type) }
     else
       false
     end
   end
 
   # @api private
   def assignable_POptionalType(t, t2)
     return true if t2.is_a?(Types::PNilType)
     if t2.is_a?(Types::POptionalType)
       assignable?(t.optional_type, t2.optional_type)
     else
       assignable?(t.optional_type, t2)
     end
   end
 
   # @api private
   def assignable_PEnumType(t, t2)
     return true if t == t2
     if t.values.empty?
       return true if t2.is_a?(Types::PStringType) || t2.is_a?(Types::PEnumType) || t2.is_a?(Types::PPatternType)
     end
     case t2
     when Types::PStringType
       # if the set of strings are all found in the set of enums
       !t2.values.empty?() && t2.values.all? { |s| t.values.any? { |e| e == s }}
     when Types::PVariantType
       t2.types.all? {|variant_t| assignable_PEnumType(t, variant_t) }
     when Types::PEnumType
       # empty means any enum
       return true if t.values.empty?
       !t2.values.empty? && t2.values.all? { |s| t.values.any? {|e| e == s }}
     else
       false
     end
   end
 
   # @api private
   def assignable_PStringType(t, t2)
     if t.values.empty?
       # A general string is assignable by any other string or pattern restricted string
       # if the string has a size constraint it does not match since there is no reasonable way
       # to compute the min/max length a pattern will match. For enum, it is possible to test that
       # each enumerator value is within range
       size_t = t.size_type || @collection_default_size_t
       case t2
       when Types::PStringType
         # true if size compliant
         size_t2 = t2.size_type || @collection_default_size_t
         assignable_PIntegerType(size_t, size_t2)
 
       when Types::PPatternType
         # true if size constraint is at least 0 to +Infinity (which is the same as the default)
         assignable_PIntegerType(size_t, @collection_default_size_t)
 
       when Types::PEnumType
         if t2.values && !t2.values.empty?
           # true if all enum values are within range
           min, max = t2.values.map(&:size).minmax
           trange =  from_to_ordered(size_t.from, size_t.to)
           t2range = [min, max]
           # If t2 min and max are within the range of t
           trange[0] <= t2range[0] && trange[1] >= t2range[1]
         else
           # enum represents all enums, and thus all strings, a sized constrained string can thus not
           # be assigned any enum (unless it is max size).
           assignable_PIntegerType(size_t, @collection_default_size_t)
         end
       else
         # no other type matches string
         false
       end
     elsif t2.is_a?(Types::PStringType)
       # A specific string acts as a set of strings - must have exactly the same strings
       # In this case, size does not matter since the definition is very precise anyway
       Set.new(t.values) == Set.new(t2.values)
     else
       # All others are false, since no other type describes the same set of specific strings
       false
     end
   end
 
   # @api private
   def assignable_PPatternType(t, t2)
     return true if t == t2
     case t2
     when Types::PStringType, Types::PEnumType
       values = t2.values
     when Types::PVariantType
       return t2.types.all? {|variant_t| assignable_PPatternType(t, variant_t) }
     when Types::PPatternType
       return t.patterns.empty? ? true : false
     else
       return false
     end
 
     if t2.values.empty?
       # Strings / Enums (unknown which ones) cannot all match a pattern, but if there is no pattern it is ok
       # (There should really always be a pattern, but better safe than sorry).
       return t.patterns.empty? ? true : false
     end
     # all strings in String/Enum type must match one of the patterns in Pattern type,
     # or Pattern represents all Patterns == all Strings
     regexps = t.patterns.map {|p| p.regexp }
     regexps.empty? || t2.values.all? { |v| regexps.any? {|re| re.match(v) } }
   end
 
   # @api private
   def assignable_PFloatType(t, t2)
     return false unless t2.is_a?(Types::PFloatType)
     trange =  from_to_ordered(t.from, t.to)
     t2range = from_to_ordered(t2.from, t2.to)
     # If t2 min and max are within the range of t
     trange[0] <= t2range[0] && trange[1] >= t2range[1]
   end
 
   # @api private
   def assignable_PBooleanType(t, t2)
     t2.is_a?(Types::PBooleanType)
   end
 
   # @api private
   def assignable_PRegexpType(t, t2)
     t2.is_a?(Types::PRegexpType) && (t.pattern.nil? || t.pattern == t2.pattern)
   end
 
   # @api private
   def assignable_PCallableType(t, t2)
     return false unless t2.is_a?(Types::PCallableType)
     # nil param_types means, any other Callable is assignable
     return true if t.param_types.nil?
 
     # NOTE: these tests are made in reverse as it is calling the callable that is constrained
     # (it's lower bound), not its upper bound
     return false unless assignable?(t2.param_types, t.param_types)
     # names are ignored, they are just information
     # Blocks must be compatible
     this_block_t = t.block_type || @nil_t
     that_block_t = t2.block_type || @nil_t
     assignable?(that_block_t, this_block_t)
 
   end
 
   # @api private
   def assignable_PCollectionType(t, t2)
     size_t = t.size_type || @collection_default_size_t
     case t2
     when Types::PCollectionType
       size_t2 = t2.size_type || @collection_default_size_t
       assignable_PIntegerType(size_t, size_t2)
     when Types::PTupleType
       # compute the tuple's min/max size, and check if that size matches
       from, to = size_range(t2.size_type)
       t2s = Types::PIntegerType.new()
       t2s.from = t2.types.size - 1 + from
       t2s.to = t2.types.size - 1 + to
       assignable_PIntegerType(size_t, t2s)
     when Types::PStructType
       from = to = t2.elements.size
       t2s = Types::PIntegerType.new()
       t2s.from = from
       t2s.to = to
       assignable_PIntegerType(size_t, t2s)
     else
       false
     end
   end
 
   # @api private
   def assignable_PType(t, t2)
     return false unless t2.is_a?(Types::PType)
     return true if t.type.nil? # wide enough to handle all types
     return false if t2.type.nil? # wider than t
     assignable?(t.type, t2.type)
   end
 
   # Array is assignable if t2 is an Array and t2's element type is assignable, or if t2 is a Tuple
   # where 
   # @api private
   def assignable_PArrayType(t, t2)
     if t2.is_a?(Types::PArrayType)
       return false unless assignable?(t.element_type, t2.element_type)
       assignable_PCollectionType(t, t2)
 
     elsif t2.is_a?(Types::PTupleType)
       return false unless t2.types.all? {|t2_element| assignable?(t.element_type, t2_element) }
       t2_regular = t2.types[0..-2]
       t2_ranged = t2.types[-1]
       t2_from, t2_to = size_range(t2.size_type)
       t2_required = t2_regular.size + t2_from
 
       t_entry = t.element_type
 
       # Tuple of anything can not be assigned (unless array is tuple of anything) - this case
       # was handled at the top of this method.
       #
       return false if t_entry.nil?
 
       # array type may be size constrained
       size_t = t.size_type || @collection_default_size_t
       min, max = size_t.range
       # Tuple with fewer min entries can not be assigned
       return false if t2_required < min
       # Tuple with more optionally available entries can not be assigned
       return false if t2_regular.size + t2_to > max
       # each tuple type must be assignable to the element type
       t2_required.times do |index|
         t2_entry = tuple_entry_at(t2, t2_from, t2_to, index)
         return false unless assignable?(t_entry, t2_entry)
       end
       # ... and so must the last, possibly optional (ranged) type
       return assignable?(t_entry, t2_ranged)
     else
       false
     end
   end
 
   # Hash is assignable if t2 is a Hash and t2's key and element types are assignable
   # @api private
   def assignable_PHashType(t, t2)
     case t2
     when Types::PHashType
       return false unless assignable?(t.key_type, t2.key_type) && assignable?(t.element_type, t2.element_type)
       assignable_PCollectionType(t, t2)
     when Types::PStructType
       # hash must accept String as key type
       # hash must accept all value types
       # hash must accept the size of the struct
       size_t = t.size_type || @collection_default_size_t
       min, max = size_t.range
       struct_size = t2.elements.size
       key_type = t.key_type
       element_type = t.element_type
       ( struct_size >= min && struct_size <= max &&
         t2.elements.all? {|e| instance_of(key_type, e.name) && assignable?(element_type, e.type) })
     else
       false
     end
   end
 
   # @api private
   def assignable_PCatalogEntryType(t1, t2)
     t2.is_a?(Types::PCatalogEntryType)
   end
 
   # @api private
   def assignable_PHostClassType(t1, t2)
     return false unless t2.is_a?(Types::PHostClassType)
     # Class = Class[name}, Class[name] != Class
     return true if t1.class_name.nil?
     # Class[name] = Class[name]
     return t1.class_name == t2.class_name
   end
 
   # @api private
   def assignable_PResourceType(t1, t2)
     return false unless t2.is_a?(Types::PResourceType)
     return true if t1.type_name.nil?
     return false if t1.type_name != t2.type_name
     return true if t1.title.nil?
     return t1.title == t2.title
   end
 
   # Data is assignable by other Data and by Array[Data] and Hash[Scalar, Data]
   # @api private
   def assignable_PDataType(t, t2)
     t2.is_a?(Types::PDataType) || assignable?(@data_variant_t, t2)
   end
 
   # Assignable if t2's has the same runtime and the runtime name resolves to
   # a class that is the same or subclass of t1's resolved runtime type name
   # @api private
   def assignable_PRuntimeType(t1, t2)
     return false unless t2.is_a?(Types::PRuntimeType)
     return false unless t1.runtime == t2.runtime
     return true if t1.runtime_type_name.nil?   # t1 is wider
     return false if t2.runtime_type_name.nil?  # t1 not nil, so t2 can not be wider
 
     # NOTE: This only supports Ruby, must change when/if the set of runtimes is expanded
     c1 = class_from_string(t1.runtime_type_name)
     c2 = class_from_string(t2.runtime_type_name)
     return false unless c1.is_a?(Class) && c2.is_a?(Class)
     !!(c2 <= c1)
   end
 
   # @api private
   def debug_string_Object(t)
     string(t)
   end
 
   # @api private
   def string_PType(t)
     if t.type.nil?
       "Type"
     else
       "Type[#{string(t.type)}]"
     end
   end
 
   # @api private
   def string_NilClass(t)     ; '?'       ; end
 
   # @api private
   def string_String(t)       ; t         ; end
 
   # @api private
   def string_Symbol(t)       ; t.to_s    ; end
 
   def string_PAnyType(t)     ; "Any"     ; end
 
   # @api private
   def string_PNilType(t)     ; 'Undef'   ; end
 
   # @api private
   def string_PDefaultType(t) ; 'Default' ; end
 
   # @api private
   def string_PBooleanType(t) ; "Boolean" ; end
 
   # @api private
   def string_PScalarType(t)  ; "Scalar"  ; end
 
   # @api private
   def string_PDataType(t)    ; "Data"    ; end
 
   # @api private
   def string_PNumericType(t) ; "Numeric" ; end
 
   # @api private
   def string_PIntegerType(t)
     range = range_array_part(t)
     unless range.empty?
       "Integer[#{range.join(', ')}]"
     else
       "Integer"
     end
   end
 
   # Produces a string from an Integer range type that is used inside other type strings
   # @api private
   def range_array_part(t)
     return [] if t.nil? || (t.from.nil? && t.to.nil?)
     [t.from.nil? ? 'default' : t.from , t.to.nil? ? 'default' : t.to ]
   end
 
   # @api private
   def string_PFloatType(t)
     range = range_array_part(t)
     unless range.empty?
       "Float[#{range.join(', ')}]"
     else
       "Float"
     end
   end
 
   # @api private
   def string_PRegexpType(t)
     t.pattern.nil? ? "Regexp" : "Regexp[#{t.regexp.inspect}]"
   end
 
   # @api private
   def string_PStringType(t)
     # skip values in regular output - see debug_string
     range = range_array_part(t.size_type)
     unless range.empty?
       "String[#{range.join(', ')}]"
     else
       "String"
     end
   end
 
   # @api private
   def debug_string_PStringType(t)
     range = range_array_part(t.size_type)
     range_part = range.empty? ? '' : '[' << range.join(' ,') << '], '
     "String[" << range_part << (t.values.map {|s| "'#{s}'" }).join(', ') << ']'
   end
 
   # @api private
   def string_PEnumType(t)
     return "Enum" if t.values.empty?
     "Enum[" << t.values.map {|s| "'#{s}'" }.join(', ') << ']'
   end
 
   # @api private
   def string_PVariantType(t)
     return "Variant" if t.types.empty?
     "Variant[" << t.types.map {|t2| string(t2) }.join(', ') << ']'
   end
 
   # @api private
   def string_PTupleType(t)
     range = range_array_part(t.size_type)
     return "Tuple" if t.types.empty?
     s = "Tuple[" << t.types.map {|t2| string(t2) }.join(', ')
     unless range.empty?
       s << ", " << range.join(', ')
     end
     s << "]"
     s
   end
 
   # @api private
   def string_PCallableType(t)
     # generic
     return "Callable" if t.param_types.nil?
 
     if t.param_types.types.empty?
       range = [0, 0]
     else
       range = range_array_part(t.param_types.size_type)
     end
     # translate to string, and skip Unit types
     types = t.param_types.types.map {|t2| string(t2) unless t2.class == Types::PUnitType }.compact
 
     s = "Callable[" << types.join(', ')
     unless range.empty?
       (s << ', ') unless types.empty?
       s << range.join(', ')
     end
     # Add block T last (after min, max) if present)
     #
     unless t.block_type.nil?
       (s << ', ') unless types.empty? && range.empty?
       s << string(t.block_type)
     end
     s << "]"
     s
   end
 
   # @api private
   def string_PStructType(t)
     return "Struct" if t.elements.empty?
     "Struct[{" << t.elements.map {|element| string(element) }.join(', ') << "}]"
   end
 
   def string_PStructElement(t)
     "'#{t.name}'=>#{string(t.type)}"
   end
 
   # @api private
   def string_PPatternType(t)
     return "Pattern" if t.patterns.empty?
     "Pattern[" << t.patterns.map {|s| "#{s.regexp.inspect}" }.join(', ') << ']'
   end
 
   # @api private
   def string_PCollectionType(t)
     range = range_array_part(t.size_type)
     unless range.empty?
       "Collection[#{range.join(', ')}]"
     else
       "Collection"
     end
   end
 
   # @api private
   def string_PUnitType(t)
     "Unit"
   end
 
   # @api private
   def string_PRuntimeType(t)   ; "Runtime[#{string(t.runtime)}, #{string(t.runtime_type_name)}]"  ; end
 
   # @api private
   def string_PArrayType(t)
     parts = [string(t.element_type)] + range_array_part(t.size_type)
     "Array[#{parts.join(', ')}]"
   end
 
   # @api private
   def string_PHashType(t)
     parts = [string(t.key_type), string(t.element_type)] + range_array_part(t.size_type)
     "Hash[#{parts.join(', ')}]"
   end
 
   # @api private
   def string_PCatalogEntryType(t)
     "CatalogEntry"
   end
 
   # @api private
   def string_PHostClassType(t)
     if t.class_name
       "Class[#{t.class_name}]"
     else
       "Class"
     end
   end
 
   # @api private
   def string_PResourceType(t)
     if t.type_name
       if t.title
         "#{capitalize_segments(t.type_name)}['#{t.title}']"
       else
         capitalize_segments(t.type_name)
       end
     else
       "Resource"
     end
   end
 
   def string_POptionalType(t)
     if t.optional_type.nil?
       "Optional"
     else
       "Optional[#{string(t.optional_type)}]"
     end
   end
 
   # Catches all non enumerable types
   # @api private
   def enumerable_Object(o)
     nil
   end
 
   # @api private
   def enumerable_PIntegerType(t)
     # Not enumerable if representing an infinite range
     return nil if t.size == TheInfinity
     t
   end
 
   def self.copy_as_tuple(t)
     case t
     when Types::PTupleType
       t.copy
     when Types::PArrayType
       # transform array to tuple
       result = Types::PTupleType.new
       result.addTypes(t.element_type.copy)
       result.size_type = t.size_type.nil? ? nil : t.size_type.copy
       result
     else
       raise ArgumentError, "Internal Error: Only Array and Tuple can be given to copy_as_tuple"
     end
   end
 
   private
 
   NAME_SEGMENT_SEPARATOR = '::'.freeze
 
   def capitalize_segments(s)
     s.split(NAME_SEGMENT_SEPARATOR).map(&:capitalize).join(NAME_SEGMENT_SEPARATOR)
   end
 
   def class_from_string(str)
     begin
       str.split(NAME_SEGMENT_SEPARATOR).inject(Object) do |memo, name_segment|
         memo.const_get(name_segment)
       end
     rescue NameError
       return nil
     end
   end
 
   def common_data?(t1, t2)
     assignable?(@data_t, t1) && assignable?(@data_t, t2)
   end
 
   def common_scalar?(t1, t2)
     assignable?(@scalar_t, t1) && assignable?(@scalar_t, t2)
   end
 
   def common_numeric?(t1, t2)
     assignable?(@numeric_t, t1) && assignable?(@numeric_t, t2)
   end
 
 end
diff --git a/spec/integration/parser/future_compiler_spec.rb b/spec/integration/parser/future_compiler_spec.rb
index dcd204f5f..f3943eed1 100644
--- a/spec/integration/parser/future_compiler_spec.rb
+++ b/spec/integration/parser/future_compiler_spec.rb
@@ -1,806 +1,811 @@
 require 'spec_helper'
 require 'puppet/pops'
 require 'puppet/parser/parser_factory'
 require 'puppet_spec/compiler'
 require 'puppet_spec/pops'
 require 'puppet_spec/scope'
 require 'matchers/resource'
 require 'rgen/metamodel_builder'
 
 # Test compilation using the future evaluator
 describe "Puppet::Parser::Compiler" do
   include PuppetSpec::Compiler
   include Matchers::Resource
 
   before :each do
     Puppet[:parser] = 'future'
   end
 
   describe "the compiler when using future parser and evaluator" do
     it "should be able to determine the configuration version from a local version control repository" do
       pending("Bug #14071 about semantics of Puppet::Util::Execute on Windows", :if => Puppet.features.microsoft_windows?) do
         # This should always work, because we should always be
         # in the puppet repo when we run this.
         version = %x{git rev-parse HEAD}.chomp
 
         Puppet.settings[:config_version] = 'git rev-parse HEAD'
 
         compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("testnode"))
         compiler.catalog.version.should == version
       end
     end
 
     it "should not create duplicate resources when a class is referenced both directly and indirectly by the node classifier (4792)" do
       node = Puppet::Node.new("testnodex")
       node.classes = ['foo', 'bar']
       catalog = compile_to_catalog(<<-PP, node)
         class foo
         {
           notify { foo_notify: }
           include bar
         }
         class bar
         {
           notify { bar_notify: }
         }
       PP
 
       catalog = Puppet::Parser::Compiler.compile(node)
 
       expect(catalog).to have_resource("Notify[foo_notify]")
       expect(catalog).to have_resource("Notify[bar_notify]")
     end
 
     it 'applies defaults for defines with qualified names (PUP-2302)' do
       catalog = compile_to_catalog(<<-CODE)
         define my::thing($msg = 'foo') { notify {'check_me': message => $msg } }
         My::Thing { msg => 'evoe' }
         my::thing { 'name': }
       CODE
 
       expect(catalog).to have_resource("Notify[check_me]").with_parameter(:message, "evoe")
     end
 
     it 'Applies defaults from dynamic scopes (3x and future with reverted PUP-867)' do
       catalog = compile_to_catalog(<<-CODE)
       class a {
         Notify { message => "defaulted" }
         include b
         notify { bye: }
       }
       class b { notify { hi: } }
 
       include a
       CODE
       expect(catalog).to have_resource("Notify[hi]").with_parameter(:message, "defaulted")
       expect(catalog).to have_resource("Notify[bye]").with_parameter(:message, "defaulted")
     end
 
     it 'gets default from inherited class (PUP-867)' do
       catalog = compile_to_catalog(<<-CODE)
       class a {
         Notify { message => "defaulted" }
         include c
         notify { bye: }
       }
       class b { Notify { message => "inherited" } }
       class c inherits b { notify { hi: } }
 
       include a
       CODE
 
       expect(catalog).to have_resource("Notify[hi]").with_parameter(:message, "inherited")
       expect(catalog).to have_resource("Notify[bye]").with_parameter(:message, "defaulted")
     end
 
     it 'looks up default parameter values from inherited class (PUP-2532)' do
       catalog = compile_to_catalog(<<-CODE)
       class a {
         Notify { message => "defaulted" }
         include c
         notify { bye: }
       }
       class b { Notify { message => "inherited" } }
       class c inherits b { notify { hi: } }
 
       include a
       notify {hi_test: message => Notify[hi][message] }
       notify {bye_test: message => Notify[bye][message] }
       CODE
 
       expect(catalog).to have_resource("Notify[hi_test]").with_parameter(:message, "inherited")
       expect(catalog).to have_resource("Notify[bye_test]").with_parameter(:message, "defaulted")
     end
 
     it 'does not allow override of class parameters using a resource override expression' do
       expect do
         compile_to_catalog(<<-CODE)
           Class[a] { x => 2}
         CODE
       end.to raise_error(/Resource Override can only.*got: Class\[a\].*/)
     end
 
     describe "when resolving class references" do
       it "should not favor local scope (with class included in topscope)" do
         catalog = compile_to_catalog(<<-PP)
           class experiment {
             class baz {
             }
             notify {"x" : require => Class[Baz] }
             notify {"y" : require => Class[Experiment::Baz] }
           }
           class baz {
           }
           include baz
           include experiment
           include experiment::baz
         PP
 
         expect(catalog).to have_resource("Notify[x]").with_parameter(:require, be_resource("Class[Baz]"))
         expect(catalog).to have_resource("Notify[y]").with_parameter(:require, be_resource("Class[Experiment::Baz]"))
       end
 
       it "should not favor local scope, (with class not included in topscope)" do
         catalog = compile_to_catalog(<<-PP)
           class experiment {
             class baz {
             }
             notify {"x" : require => Class[Baz] }
             notify {"y" : require => Class[Experiment::Baz] }
           }
           class baz {
           }
           include experiment
           include experiment::baz
         PP
 
         expect(catalog).to have_resource("Notify[x]").with_parameter(:require, be_resource("Class[Baz]"))
         expect(catalog).to have_resource("Notify[y]").with_parameter(:require, be_resource("Class[Experiment::Baz]"))
       end
     end
 
     describe "(ticket #13349) when explicitly specifying top scope" do
       ["class {'::bar::baz':}", "include ::bar::baz"].each do |include|
         describe "with #{include}" do
           it "should find the top level class" do
             catalog = compile_to_catalog(<<-MANIFEST)
               class { 'foo::test': }
               class foo::test {
               	#{include}
               }
               class bar::baz {
               	notify { 'good!': }
               }
               class foo::bar::baz {
               	notify { 'bad!': }
               }
             MANIFEST
 
             expect(catalog).to have_resource("Class[Bar::Baz]")
             expect(catalog).to have_resource("Notify[good!]")
             expect(catalog).to_not have_resource("Class[Foo::Bar::Baz]")
             expect(catalog).to_not have_resource("Notify[bad!]")
           end
         end
       end
     end
 
     it "should recompute the version after input files are re-parsed" do
       Puppet[:code] = 'class foo { }'
       Time.stubs(:now).returns(1)
       node = Puppet::Node.new('mynode')
       Puppet::Parser::Compiler.compile(node).version.should == 1
       Time.stubs(:now).returns(2)
       Puppet::Parser::Compiler.compile(node).version.should == 1 # no change because files didn't change
       Puppet::Resource::TypeCollection.any_instance.stubs(:stale?).returns(true).then.returns(false) # pretend change
       Puppet::Parser::Compiler.compile(node).version.should == 2
     end
 
     ['define', 'class', 'node'].each do |thing|
       it "'#{thing}' is not allowed inside evaluated conditional constructs" do
         expect do
           compile_to_catalog(<<-PP)
             if true {
               #{thing} foo {
               }
               notify { decoy: }
             }
           PP
         end.to raise_error(Puppet::Error, /Classes, definitions, and nodes may only appear at toplevel/)
       end
 
       it "'#{thing}' is not allowed inside un-evaluated conditional constructs" do
         expect do
           compile_to_catalog(<<-PP)
             if false {
               #{thing} foo {
               }
               notify { decoy: }
             }
           PP
         end.to raise_error(Puppet::Error, /Classes, definitions, and nodes may only appear at toplevel/)
       end
     end
 
     describe "relationships can be formed" do
       def extract_name(ref)
         ref.sub(/File\[(\w+)\]/, '\1')
       end
 
       def assert_creates_relationships(relationship_code, expectations)
         base_manifest = <<-MANIFEST
           file { [a,b,c]:
             mode => '0644',
           }
           file { [d,e]:
             mode => '0755',
           }
         MANIFEST
         catalog = compile_to_catalog(base_manifest + relationship_code)
 
         resources = catalog.resources.select { |res| res.type == 'File' }
 
         actual_relationships, actual_subscriptions = [:before, :notify].map do |relation|
           resources.map do |res|
             dependents = Array(res[relation])
             dependents.map { |ref| [res.title, extract_name(ref)] }
           end.inject(&:concat)
         end
 
         actual_relationships.should =~ (expectations[:relationships] || [])
         actual_subscriptions.should =~ (expectations[:subscriptions] || [])
       end
 
       it "of regular type" do
         assert_creates_relationships("File[a] -> File[b]",
                                      :relationships => [['a','b']])
       end
 
       it "of subscription type" do
         assert_creates_relationships("File[a] ~> File[b]",
                                      :subscriptions => [['a', 'b']])
       end
 
       it "between multiple resources expressed as resource with multiple titles" do
         assert_creates_relationships("File[a,b] -> File[c,d]",
                                      :relationships => [['a', 'c'],
                                                         ['b', 'c'],
                                                         ['a', 'd'],
                                                         ['b', 'd']])
       end
 
       it "between collection expressions" do
         assert_creates_relationships("File <| mode == '0644' |> -> File <| mode == '0755' |>",
                                      :relationships => [['a', 'd'],
                                                         ['b', 'd'],
                                                         ['c', 'd'],
                                                         ['a', 'e'],
                                                         ['b', 'e'],
                                                         ['c', 'e']])
       end
 
       it "between resources expressed as Strings" do
         assert_creates_relationships("'File[a]' -> 'File[b]'",
                                      :relationships => [['a', 'b']])
       end
 
       it "between resources expressed as variables" do
         assert_creates_relationships(<<-MANIFEST, :relationships => [['a', 'b']])
           $var = File[a]
           $var -> File[b]
         MANIFEST
 
       end
 
       it "between resources expressed as case statements" do
         assert_creates_relationships(<<-MANIFEST, :relationships => [['s1', 't2']])
           $var = 10
           case $var {
             10: {
               file { s1: }
             }
             12: {
               file { s2: }
             }
           }
           ->
           case $var + 2 {
             10: {
               file { t1: }
             }
             12: {
               file { t2: }
             }
           }
         MANIFEST
       end
 
       it "using deep access in array" do
         assert_creates_relationships(<<-MANIFEST, :relationships => [['a', 'b']])
           $var = [ [ [ File[a], File[b] ] ] ]
           $var[0][0][0] -> $var[0][0][1]
         MANIFEST
 
       end
 
       it "using deep access in hash" do
         assert_creates_relationships(<<-MANIFEST, :relationships => [['a', 'b']])
           $var = {'foo' => {'bar' => {'source' => File[a], 'target' => File[b]}}}
           $var[foo][bar][source] -> $var[foo][bar][target]
         MANIFEST
 
       end
 
       it "using resource declarations" do
         assert_creates_relationships("file { l: } -> file { r: }", :relationships => [['l', 'r']])
       end
 
       it "between entries in a chain of relationships" do
         assert_creates_relationships("File[a] -> File[b] ~> File[c] <- File[d] <~ File[e]",
                                      :relationships => [['a', 'b'], ['d', 'c']],
                                      :subscriptions => [['b', 'c'], ['e', 'd']])
       end
     end
 
     context "when dealing with variable references" do
       it 'an initial underscore in a variable name is ok' do
         catalog = compile_to_catalog(<<-MANIFEST)
           class a { $_a = 10}
           include a
           notify { 'test': message => $a::_a }
         MANIFEST
 
         expect(catalog).to have_resource("Notify[test]").with_parameter(:message, 10)
       end
 
       it 'an initial underscore in not ok if elsewhere than last segment' do
         expect do
           catalog = compile_to_catalog(<<-MANIFEST)
             class a { $_a = 10}
             include a
             notify { 'test': message => $_a::_a }
           MANIFEST
         end.to raise_error(/Illegal variable name/)
       end
 
       it 'a missing variable as default value becomes undef' do
         # strict variables not on
         catalog = compile_to_catalog(<<-MANIFEST)
         class a ($b=$x) { notify {test: message=>"yes ${undef == $b}" } }
           include a
         MANIFEST
 
         expect(catalog).to have_resource("Notify[test]").with_parameter(:message, "yes true")
       end
     end
 
     context 'when working with the trusted data hash' do
       context 'and have opted in to hashed_node_data' do
         before :each do
           Puppet[:trusted_node_data] = true
         end
 
         it 'should make $trusted available' do
           node = Puppet::Node.new("testing")
           node.trusted_data = { "data" => "value" }
 
           catalog = compile_to_catalog(<<-MANIFEST, node)
             notify { 'test': message => $trusted[data] }
           MANIFEST
 
           expect(catalog).to have_resource("Notify[test]").with_parameter(:message, "value")
         end
 
         it 'should not allow assignment to $trusted' do
           node = Puppet::Node.new("testing")
           node.trusted_data = { "data" => "value" }
 
           expect do
             compile_to_catalog(<<-MANIFEST, node)
               $trusted = 'changed'
               notify { 'test': message => $trusted == 'changed' }
             MANIFEST
           end.to raise_error(Puppet::Error, /Attempt to assign to a reserved variable name: 'trusted'/)
         end
       end
 
       context 'and have not opted in to hashed_node_data' do
         before :each do
           Puppet[:trusted_node_data] = false
         end
 
         it 'should not make $trusted available' do
           node = Puppet::Node.new("testing")
           node.trusted_data = { "data" => "value" }
 
           catalog = compile_to_catalog(<<-MANIFEST, node)
             notify { 'test': message => ($trusted == undef) }
           MANIFEST
 
           expect(catalog).to have_resource("Notify[test]").with_parameter(:message, true)
         end
 
         it 'should allow assignment to $trusted' do
           catalog = compile_to_catalog(<<-MANIFEST)
             $trusted = 'changed'
             notify { 'test': message => $trusted == 'changed' }
           MANIFEST
 
           expect(catalog).to have_resource("Notify[test]").with_parameter(:message, true)
         end
       end
     end
 
     context 'when using typed parameters in definition' do
       it 'accepts type compliant arguments' do
         catalog = compile_to_catalog(<<-MANIFEST)
           define foo(String $x) { }
           foo { 'test': x =>'say friend' }
         MANIFEST
         expect(catalog).to have_resource("Foo[test]").with_parameter(:x, 'say friend')
       end
 
       it 'accepts undef as the default for an Optional argument' do
         catalog = compile_to_catalog(<<-MANIFEST)
           define foo(Optional[String] $x = undef) {
             notify { "expected": message => $x == undef }
           }
           foo { 'test': }
         MANIFEST
         expect(catalog).to have_resource("Notify[expected]").with_parameter(:message, true)
       end
 
       it 'accepts anything when parameters are untyped' do
         expect do
           catalog = compile_to_catalog(<<-MANIFEST)
           define foo($a, $b, $c) { }
           foo { 'test': a => String, b=>10, c=>undef }
         MANIFEST
         end.to_not raise_error()
       end
 
       it 'denies non type compliant arguments' do
         expect do
           catalog = compile_to_catalog(<<-MANIFEST)
             define foo(Integer $x) { }
             foo { 'test': x =>'say friend' }
           MANIFEST
         end.to raise_error(/type Integer, got String/)
       end
 
       it 'denies undef for a non-optional type' do
         expect do
           catalog = compile_to_catalog(<<-MANIFEST)
             define foo(Integer $x) { }
             foo { 'test': x => undef }
           MANIFEST
         end.to raise_error(/type Integer, got Undef/)
       end
 
       it 'denies non type compliant default argument' do
         expect do
           catalog = compile_to_catalog(<<-MANIFEST)
             define foo(Integer $x = 'pow') { }
             foo { 'test':  }
           MANIFEST
         end.to raise_error(/type Integer, got String/)
       end
 
       it 'denies undef as the default for a non-optional type' do
         expect do
           catalog = compile_to_catalog(<<-MANIFEST)
             define foo(Integer $x = undef) { }
             foo { 'test':  }
           MANIFEST
         end.to raise_error(/type Integer, got Undef/)
       end
 
       it 'accepts a Resource as a Type' do
         catalog = compile_to_catalog(<<-MANIFEST)
           define foo(Type[Bar] $x) {
             notify { 'test': message => $x[text] }
           }
           define bar($text) { }
           bar { 'joke': text => 'knock knock' }
           foo { 'test': x => Bar[joke] }
         MANIFEST
         expect(catalog).to have_resource("Notify[test]").with_parameter(:message, 'knock knock')
       end
     end
 
     context 'when using typed parameters in class' do
       it 'accepts type compliant arguments' do
         catalog = compile_to_catalog(<<-MANIFEST)
           class foo(String $x) { }
           class { 'foo': x =>'say friend' }
         MANIFEST
         expect(catalog).to have_resource("Class[Foo]").with_parameter(:x, 'say friend')
       end
 
       it 'accepts undef as the default for an Optional argument' do
         catalog = compile_to_catalog(<<-MANIFEST)
           class foo(Optional[String] $x = undef) {
             notify { "expected": message => $x == undef }
           }
           class { 'foo': }
         MANIFEST
         expect(catalog).to have_resource("Notify[expected]").with_parameter(:message, true)
       end
 
       it 'accepts anything when parameters are untyped' do
         expect do
           catalog = compile_to_catalog(<<-MANIFEST)
             class foo($a, $b, $c) { }
             class { 'foo': a => String, b=>10, c=>undef }
           MANIFEST
         end.to_not raise_error()
       end
 
       it 'denies non type compliant arguments' do
         expect do
           catalog = compile_to_catalog(<<-MANIFEST)
             class foo(Integer $x) { }
             class { 'foo': x =>'say friend' }
           MANIFEST
         end.to raise_error(/type Integer, got String/)
       end
 
       it 'denies undef for a non-optional type' do
         expect do
           catalog = compile_to_catalog(<<-MANIFEST)
             class foo(Integer $x) { }
             class { 'foo': x => undef }
           MANIFEST
         end.to raise_error(/type Integer, got Undef/)
       end
 
       it 'denies non type compliant default argument' do
         expect do
           catalog = compile_to_catalog(<<-MANIFEST)
             class foo(Integer $x = 'pow') { }
             class { 'foo':  }
           MANIFEST
         end.to raise_error(/type Integer, got String/)
       end
 
       it 'denies undef as the default for a non-optional type' do
         expect do
           catalog = compile_to_catalog(<<-MANIFEST)
             class foo(Integer $x = undef) { }
             class { 'foo':  }
           MANIFEST
         end.to raise_error(/type Integer, got Undef/)
       end
 
       it 'accepts a Resource as a Type' do
         catalog = compile_to_catalog(<<-MANIFEST)
           class foo(Type[Bar] $x) {
             notify { 'test': message => $x[text] }
           }
           define bar($text) { }
           bar { 'joke': text => 'knock knock' }
           class { 'foo': x => Bar[joke] }
         MANIFEST
         expect(catalog).to have_resource("Notify[test]").with_parameter(:message, 'knock knock')
       end
     end
 
     context 'when using typed parameters in lambdas' do
       it 'accepts type compliant arguments' do
         catalog = compile_to_catalog(<<-MANIFEST)
           with('value') |String $x| { notify { "$x": } }
         MANIFEST
         expect(catalog).to have_resource("Notify[value]")
       end
 
       it 'handles an array as a single argument' do
         catalog = compile_to_catalog(<<-MANIFEST)
           with(['value', 'second']) |$x| { notify { "${x[0]} ${x[1]}": } }
         MANIFEST
         expect(catalog).to have_resource("Notify[value second]")
       end
 
-      it 'denies when missing required arguments' do
-        expect do
-          compile_to_catalog(<<-MANIFEST)
-            with(1) |$x, $y| { }
-          MANIFEST
-        end.to raise_error(/Parameter \$y is required but no value was given/m)
+      # Conditinoally left out for Ruby 1.8.x since the Proc created for the expected number of arguments will accept
+      # a call with fewer arguments and then pass all arguments to the closure. The closure then receives an argument
+      # array of correct size with nil values instead of an array with too few arguments
+      unless RUBY_VERSION[0,3] == '1.8'
+        it 'denies when missing required arguments' do
+          expect do
+            compile_to_catalog(<<-MANIFEST)
+              with(1) |$x, $y| { }
+            MANIFEST
+          end.to raise_error(/Parameter \$y is required but no value was given/m)
+        end
       end
 
       it 'accepts anything when parameters are untyped' do
         catalog = compile_to_catalog(<<-MANIFEST)
           ['value', 1, true, undef].each |$x| { notify { "value: $x": } }
         MANIFEST
 
         expect(catalog).to have_resource("Notify[value: value]")
         expect(catalog).to have_resource("Notify[value: 1]")
         expect(catalog).to have_resource("Notify[value: true]")
         expect(catalog).to have_resource("Notify[value: ]")
       end
 
       it 'accepts type-compliant, slurped arguments' do
         catalog = compile_to_catalog(<<-MANIFEST)
           with(1, 2) |Integer *$x| { notify { "${$x[0] + $x[1]}": } }
         MANIFEST
         expect(catalog).to have_resource("Notify[3]")
       end
 
       it 'denies non-type-compliant arguments' do
         expect do
           compile_to_catalog(<<-MANIFEST)
             with(1) |String $x| { }
           MANIFEST
         end.to raise_error(/expected.*String.*actual.*Integer/m)
       end
 
       it 'denies non-type-compliant, slurped arguments' do
         expect do
           compile_to_catalog(<<-MANIFEST)
             with(1, "hello") |Integer *$x| { }
           MANIFEST
         end.to raise_error(/called with mis-matched arguments.*expected.*Integer.*actual.*Integer, String/m)
       end
 
       it 'denies non-type-compliant default argument' do
         expect do
           compile_to_catalog(<<-MANIFEST)
             with(1) |$x, String $defaulted = 1| { notify { "${$x + $defaulted}": }}
           MANIFEST
         end.to raise_error(/expected.*Any.*String.*actual.*Integer.*Integer/m)
       end
 
       it 'raises an error when a default argument value is an incorrect type and there are no arguments passed' do
         expect do
           compile_to_catalog(<<-MANIFEST)
             with() |String $defaulted = 1| {}
           MANIFEST
         end.to raise_error(/expected.*String.*actual.*Integer/m)
       end
 
       it 'raises an error when the default argument for a slurped parameter is an incorrect type' do
         expect do
           compile_to_catalog(<<-MANIFEST)
             with() |String *$defaulted = 1| {}
           MANIFEST
         end.to raise_error(/expected.*String.*actual.*Integer/m)
       end
 
       it 'allows using an array as the default slurped value' do
         catalog = compile_to_catalog(<<-MANIFEST)
           with() |String *$defaulted = [hi]| { notify { $defaulted[0]: } }
         MANIFEST
 
         expect(catalog).to have_resource('Notify[hi]')
       end
 
       it 'allows using a value of the type as the default slurped value' do
         catalog = compile_to_catalog(<<-MANIFEST)
           with() |String *$defaulted = hi| { notify { $defaulted[0]: } }
         MANIFEST
 
         expect(catalog).to have_resource('Notify[hi]')
       end
 
       it 'allows specifying the type of a slurped parameter as an array' do
         catalog = compile_to_catalog(<<-MANIFEST)
           with() |Array[String] *$defaulted = hi| { notify { $defaulted[0]: } }
         MANIFEST
 
         expect(catalog).to have_resource('Notify[hi]')
       end
 
       it 'raises an error when the number of default values does not match the parameter\'s size specification' do
         expect do
           compile_to_catalog(<<-MANIFEST)
             with() |Array[String, 2] *$defaulted = hi| { }
           MANIFEST
         end.to raise_error(/expected.*arg count \{2,\}.*actual.*arg count \{1\}/m)
       end
 
       it 'raises an error when the number of passed values does not match the parameter\'s size specification' do
         expect do
           compile_to_catalog(<<-MANIFEST)
             with(hi) |Array[String, 2] *$passed| { }
           MANIFEST
         end.to raise_error(/expected.*arg count \{2,\}.*actual.*arg count \{1\}/m)
       end
 
       it 'matches when the number of arguments passed for a slurp parameter match the size specification' do
         catalog = compile_to_catalog(<<-MANIFEST)
           with(hi, bye) |Array[String, 2] *$passed| {
             $passed.each |$n| { notify { $n: } }
           }
         MANIFEST
 
         expect(catalog).to have_resource('Notify[hi]')
         expect(catalog).to have_resource('Notify[bye]')
       end
 
       it 'raises an error when the number of allowed slurp parameters exceeds the size constraint' do
         expect do
           compile_to_catalog(<<-MANIFEST)
             with(hi, bye) |Array[String, 1, 1] *$passed| { }
           MANIFEST
         end.to raise_error(/expected.*arg count \{1\}.*actual.*arg count \{2\}/m)
       end
 
       it 'allows passing slurped arrays by specifying an array of arrays' do
         catalog = compile_to_catalog(<<-MANIFEST)
           with([hi], [bye]) |Array[Array[String, 1, 1]] *$passed| {
             notify { $passed[0][0]: }
             notify { $passed[1][0]: }
           }
         MANIFEST
 
         expect(catalog).to have_resource('Notify[hi]')
         expect(catalog).to have_resource('Notify[bye]')
       end
 
       it 'raises an error when a required argument follows an optional one' do
         expect do
           compile_to_catalog(<<-MANIFEST)
             with() |$y = first, $x, Array[String, 1] *$passed = bye| {}
           MANIFEST
         end.to raise_error(/Parameter \$x is required/)
       end
 
       it 'raises an error when the minimum size of a slurped argument makes it required and it follows an optional argument' do
         expect do
           compile_to_catalog(<<-MANIFEST)
             with() |$x = first, Array[String, 1] *$passed| {}
           MANIFEST
         end.to raise_error(/Parameter \$passed is required/)
       end
 
       it 'allows slurped arguments with a minimum size of 0 after an optional argument' do
         catalog = compile_to_catalog(<<-MANIFEST)
           with() |$x = first, Array[String, 0] *$passed| {
             notify { $x: }
           }
         MANIFEST
 
         expect(catalog).to have_resource('Notify[first]')
       end
 
       it 'accepts a Resource as a Type' do
         catalog = compile_to_catalog(<<-MANIFEST)
           define bar($text) { }
           bar { 'joke': text => 'knock knock' }
 
           with(Bar[joke]) |Type[Bar] $joke| { notify { "${joke[text]}": } }
         MANIFEST
         expect(catalog).to have_resource("Notify[knock knock]")
       end
     end
   end
 
   context 'when evaluating collection' do
     it 'matches on container inherited tags' do
       Puppet[:code] = <<-MANIFEST
       class xport_test {
         tag('foo_bar')
         @notify { 'nbr1':
           message => 'explicitly tagged',
           tag => 'foo_bar'
         }
 
         @notify { 'nbr2':
           message => 'implicitly tagged'
         }
 
         Notify <| tag == 'foo_bar' |> {
           message => 'overridden'
         }
       }
       include xport_test
       MANIFEST
 
       catalog = Puppet::Parser::Compiler.compile(Puppet::Node.new("mynode"))
 
       expect(catalog).to have_resource("Notify[nbr1]").with_parameter(:message, 'overridden')
       expect(catalog).to have_resource("Notify[nbr2]").with_parameter(:message, 'overridden')
     end
   end
 
 end
diff --git a/spec/unit/functions/assert_type_spec.rb b/spec/unit/functions/assert_type_spec.rb
index 13b353401..f2d236200 100644
--- a/spec/unit/functions/assert_type_spec.rb
+++ b/spec/unit/functions/assert_type_spec.rb
@@ -1,78 +1,57 @@
 require 'spec_helper'
 require 'puppet/pops'
 require 'puppet/loaders'
 
 describe 'the assert_type function' do
-
   after(:all) { Puppet::Pops::Loaders.clear }
 
-  around(:each) do |example|
-    loaders = Puppet::Pops::Loaders.new(Puppet::Node::Environment.create(:testing, []))
-    Puppet.override({:loaders => loaders}, "test-example") do
-      example.run
-    end
-  end
-
-  let(:func) do
-    Puppet.lookup(:loaders).puppet_system_loader.load(:function, 'assert_type')
-  end
+  let(:loaders) { Puppet::Pops::Loaders.new(Puppet::Node::Environment.create(:testing, [])) }
+  let(:func) { loaders.puppet_system_loader.load(:function, 'assert_type') }
 
   it 'asserts compliant type by returning the value' do
     expect(func.call({}, type(String), 'hello world')).to eql('hello world')
   end
 
   it 'accepts type given as a String' do
     expect(func.call({}, 'String', 'hello world')).to eql('hello world')
   end
 
   it 'asserts non compliant type by raising an error' do
     expect do
       func.call({}, type(Integer), 'hello world')
     end.to raise_error(Puppet::ParseError, /does not match actual/)
   end
 
   it 'checks that first argument is a type' do
     expect do
       func.call({}, 10, 10)
     end.to raise_error(ArgumentError, Regexp.new(Regexp.escape(
 "function 'assert_type' called with mis-matched arguments
 expected one of:
   assert_type(Type type, Any value, Callable[Type, Type] block {0,1}) - arg count {2,3}
   assert_type(String type_string, Any value, Callable[Type, Type] block {0,1}) - arg count {2,3}
 actual:
   assert_type(Integer, Integer) - arg count {2}")))
   end
 
   it 'allows the second arg to be undef/nil)' do
     expect do
       func.call({}, optional(String), nil)
     end.to_not raise_error
   end
 
   it 'can be called with a callable that receives a specific type' do
-    expected, actual = func.call({}, optional(String), 1, create_callable_2_args_unit)
+    expected, actual, actual2 = func.call({}, 'Optional[String]', 1) { |expected, actual| [expected, actual, actual] }
     expect(expected.to_s).to eql('Optional[String]')
     expect(actual.to_s).to eql('Integer[1, 1]')
+    expect(actual2.to_s).to eql('Integer[1, 1]')
   end
 
   def optional(type_ref)
     Puppet::Pops::Types::TypeFactory.optional(type(type_ref))
   end
 
   def type(type_ref)
     Puppet::Pops::Types::TypeFactory.type_of(type_ref)
   end
-
-  def create_callable_2_args_unit()
-    Puppet::Functions.create_function(:func) do
-      dispatch :func do
-        param 'Type', 'expected'
-        param 'Type', 'actual'
-      end
-
-      def func(expected, actual)
-        [expected, actual]
-      end
-    end.new({}, nil)
-  end
 end
diff --git a/spec/unit/functions/with_spec.rb b/spec/unit/functions/with_spec.rb
index 952b14412..ac04a7be9 100644
--- a/spec/unit/functions/with_spec.rb
+++ b/spec/unit/functions/with_spec.rb
@@ -1,35 +1,40 @@
 require 'spec_helper'
 
 require 'puppet_spec/compiler'
 require 'matchers/resource'
 
 describe 'the with function' do
   include PuppetSpec::Compiler
   include Matchers::Resource
 
   before :each do
     Puppet[:parser] = 'future'
   end
 
   it 'calls a lambda passing no arguments' do
     expect(compile_to_catalog("with() || { notify { testing: } }")).to have_resource('Notify[testing]')
   end
 
   it 'calls a lambda passing a single argument' do
     expect(compile_to_catalog('with(1) |$x| { notify { "testing$x": } }')).to have_resource('Notify[testing1]')
   end
 
   it 'calls a lambda passing more than one argument' do
     expect(compile_to_catalog('with(1, 2) |*$x| { notify { "testing${x[0]}, ${x[1]}": } }')).to have_resource('Notify[testing1, 2]')
   end
 
   it 'passes a type reference to a lambda' do
     expect(compile_to_catalog('notify { test: message => "data" } with(Notify[test]) |$x| { notify { "${x[message]}": } }')).to have_resource('Notify[data]')
   end
 
-  it 'errors when not given enough arguments for the lambda' do
-    expect do
-      compile_to_catalog('with(1) |$x, $y| { }')
-    end.to raise_error(/Parameter \$y is required but no value was given/m)
+  # Conditinoally left out for Ruby 1.8.x since the Proc created for the expected number of arguments will accept
+  # a call with fewer arguments and then pass all arguments to the closure. The closure then receives an argument
+  # array of correct size with nil values instead of an array with too few arguments
+  unless RUBY_VERSION[0,3] == '1.8'
+    it 'errors when not given enough arguments for the lambda' do
+      expect do
+        compile_to_catalog('with(1) |$x, $y| { }')
+      end.to raise_error(/Parameter \$y is required but no value was given/m)
+    end
   end
 end
diff --git a/spec/unit/functions4_spec.rb b/spec/unit/functions4_spec.rb
index ef428b2c6..cc95f0d79 100644
--- a/spec/unit/functions4_spec.rb
+++ b/spec/unit/functions4_spec.rb
@@ -1,692 +1,677 @@
 require 'spec_helper'
 require 'puppet/pops'
 require 'puppet/loaders'
 require 'puppet_spec/pops'
 require 'puppet_spec/scope'
 
 module FunctionAPISpecModule
   class TestDuck
   end
 
   class TestFunctionLoader < Puppet::Pops::Loader::StaticLoader
     def initialize
       @functions = {}
     end
 
     def add_function(name, function)
       typed_name = Puppet::Pops::Loader::Loader::TypedName.new(:function, name)
       entry = Puppet::Pops::Loader::Loader::NamedEntry.new(typed_name, function, __FILE__)
       @functions[typed_name] = entry
     end
 
     # override StaticLoader
     def load_constant(typed_name)
       @functions[typed_name]
     end
   end
 end
 
 describe 'the 4x function api' do
   include FunctionAPISpecModule
   include PuppetSpec::Pops
   include PuppetSpec::Scope
 
   let(:loader) { FunctionAPISpecModule::TestFunctionLoader.new }
 
   it 'allows a simple function to be created without dispatch declaration' do
     f = Puppet::Functions.create_function('min') do
       def min(x,y)
         x <= y ? x : y
       end
     end
 
     # the produced result is a Class inheriting from Function
     expect(f.class).to be(Class)
     expect(f.superclass).to be(Puppet::Functions::Function)
     # and this class had the given name (not a real Ruby class name)
     expect(f.name).to eql('min')
   end
 
   it 'refuses to create functions that are not based on the Function class' do
     expect do
       Puppet::Functions.create_function('testing', Object) {}
     end.to raise_error(ArgumentError, 'Functions must be based on Puppet::Pops::Functions::Function. Got Object')
   end
 
   it 'a function without arguments can be defined and called without dispatch declaration' do
     f = create_noargs_function_class()
     func = f.new(:closure_scope, :loader)
     expect(func.call({})).to eql(10)
   end
 
   it 'an error is raised when calling a no arguments function with arguments' do
     f = create_noargs_function_class()
     func = f.new(:closure_scope, :loader)
     expect{func.call({}, 'surprise')}.to raise_error(ArgumentError, "function 'test' called with mis-matched arguments
 expected:
   test() - arg count {0}
 actual:
   test(String) - arg count {1}")
   end
 
   it 'a simple function can be called' do
     f = create_min_function_class()
     # TODO: Bogus parameters, not yet used
     func = f.new(:closure_scope, :loader)
     expect(func.is_a?(Puppet::Functions::Function)).to be_true
     expect(func.call({}, 10,20)).to eql(10)
   end
 
   it 'an error is raised if called with too few arguments' do
     f = create_min_function_class()
     # TODO: Bogus parameters, not yet used
     func = f.new(:closure_scope, :loader)
     expect(func.is_a?(Puppet::Functions::Function)).to be_true
     signature = if RUBY_VERSION =~ /^1\.8/
       'Any{2}'
     else
       'Any x, Any y'
     end
     expect do
       func.call({}, 10)
     end.to raise_error(ArgumentError, "function 'min' called with mis-matched arguments
 expected:
   min(#{signature}) - arg count {2}
 actual:
   min(Integer) - arg count {1}")
   end
 
   it 'an error is raised if called with too many arguments' do
     f = create_min_function_class()
     # TODO: Bogus parameters, not yet used
     func = f.new(:closure_scope, :loader)
     expect(func.is_a?(Puppet::Functions::Function)).to be_true
     signature = if RUBY_VERSION =~ /^1\.8/
       'Any{2}'
     else
       'Any x, Any y'
     end
     expect do
       func.call({}, 10, 10, 10)
     end.to raise_error(ArgumentError, Regexp.new(Regexp.escape(
 "function 'min' called with mis-matched arguments
 expected:
   min(#{signature}) - arg count {2}
 actual:
   min(Integer, Integer, Integer) - arg count {3}")))
   end
 
   it 'an error is raised if simple function-name and method are not matched' do
     expect do
       f = create_badly_named_method_function_class()
     end.to raise_error(ArgumentError, /Function Creation Error, cannot create a default dispatcher for function 'mix', no method with this name found/)
   end
 
   it 'the implementation separates dispatchers for different functions' do
     # this tests that meta programming / construction puts class attributes in the correct class
     f1 = create_min_function_class()
     f2 = create_max_function_class()
 
     d1 = f1.dispatcher
     d2 = f2.dispatcher
 
     expect(d1).to_not eql(d2)
     expect(d1.dispatchers[0]).to_not eql(d2.dispatchers[0])
   end
 
   context 'when using regular dispatch' do
     it 'a function can be created using dispatch and called' do
       f = create_min_function_class_using_dispatch()
       func = f.new(:closure_scope, :loader)
       expect(func.call({}, 3,4)).to eql(3)
     end
 
     it 'an error is raised with reference to given parameter names when called with mis-matched arguments' do
       f = create_min_function_class_using_dispatch()
       # TODO: Bogus parameters, not yet used
       func = f.new(:closure_scope, :loader)
       expect(func.is_a?(Puppet::Functions::Function)).to be_true
       expect do
         func.call({}, 10, 10, 10)
       end.to raise_error(ArgumentError, Regexp.new(Regexp.escape(
 "function 'min' called with mis-matched arguments
 expected:
   min(Numeric a, Numeric b) - arg count {2}
 actual:
   min(Integer, Integer, Integer) - arg count {3}")))
     end
 
     it 'an error includes optional indicators and count for last element' do
       f = create_function_with_optionals_and_varargs()
       # TODO: Bogus parameters, not yet used
       func = f.new(:closure_scope, :loader)
       expect(func.is_a?(Puppet::Functions::Function)).to be_true
       signature = if RUBY_VERSION =~ /^1\.8/
         'Any{2,}'
       else
         'Any x, Any y, Any a?, Any b?, Any c{0,}'
       end
       expect do
         func.call({}, 10)
       end.to raise_error(ArgumentError,
 "function 'min' called with mis-matched arguments
 expected:
   min(#{signature}) - arg count {2,}
 actual:
   min(Integer) - arg count {1}")
     end
 
     it 'an error includes optional indicators and count for last element when defined via dispatch' do
       f = create_function_with_optionals_and_varargs_via_dispatch()
       # TODO: Bogus parameters, not yet used
       func = f.new(:closure_scope, :loader)
       expect(func.is_a?(Puppet::Functions::Function)).to be_true
       expect do
         func.call({}, 10)
       end.to raise_error(ArgumentError,
 "function 'min' called with mis-matched arguments
 expected:
   min(Numeric x, Numeric y, Numeric a?, Numeric b?, Numeric c{0,}) - arg count {2,}
 actual:
   min(Integer) - arg count {1}")
     end
 
     it 'a function can be created using dispatch and called' do
       f = create_min_function_class_disptaching_to_two_methods()
       func = f.new(:closure_scope, :loader)
       expect(func.call({}, 3,4)).to eql(3)
       expect(func.call({}, 'Apple', 'Banana')).to eql('Apple')
     end
 
     it 'an error is raised with reference to multiple methods when called with mis-matched arguments' do
       f = create_min_function_class_disptaching_to_two_methods()
       # TODO: Bogus parameters, not yet used
       func = f.new(:closure_scope, :loader)
       expect(func.is_a?(Puppet::Functions::Function)).to be_true
       expect do
         func.call({}, 10, 10, 10)
       end.to raise_error(ArgumentError,
 "function 'min' called with mis-matched arguments
 expected one of:
   min(Numeric a, Numeric b) - arg count {2}
   min(String s1, String s2) - arg count {2}
 actual:
   min(Integer, Integer, Integer) - arg count {3}")
     end
 
     context 'can use injection' do
       before :all do
         injector = Puppet::Pops::Binder::Injector.create('test') do
           bind.name('a_string').to('evoe')
           bind.name('an_int').to(42)
         end
         Puppet.push_context({:injector => injector}, "injector for testing function API")
       end
 
       after :all do
         Puppet.pop_context()
       end
 
       it 'attributes can be injected' do
         f1 = create_function_with_class_injection()
         f = f1.new(:closure_scope, :loader)
         expect(f.test_attr2()).to eql("evoe")
         expect(f.serial().produce(nil)).to eql(42)
         expect(f.test_attr().class.name).to eql("FunctionAPISpecModule::TestDuck")
       end
 
       it 'parameters can be injected and woven with regular dispatch' do
         f1 = create_function_with_param_injection_regular()
         f = f1.new(:closure_scope, :loader)
         expect(f.call(nil, 10, 20)).to eql("evoe! 10, and 20 < 42 = true")
         expect(f.call(nil, 50, 20)).to eql("evoe! 50, and 20 < 42 = false")
       end
     end
 
     context 'when requesting a type' do
       it 'responds with a Callable for a single signature' do
         tf = Puppet::Pops::Types::TypeFactory
         fc = create_min_function_class_using_dispatch()
         t = fc.dispatcher.to_type
         expect(t.class).to be(Puppet::Pops::Types::PCallableType)
         expect(t.param_types.class).to be(Puppet::Pops::Types::PTupleType)
         expect(t.param_types.types).to eql([tf.numeric(), tf.numeric()])
         expect(t.block_type).to be_nil
       end
 
       it 'responds with a Variant[Callable...] for multiple signatures' do
         tf = Puppet::Pops::Types::TypeFactory
         fc = create_min_function_class_disptaching_to_two_methods()
         t = fc.dispatcher.to_type
         expect(t.class).to be(Puppet::Pops::Types::PVariantType)
         expect(t.types.size).to eql(2)
         t1 = t.types[0]
         expect(t1.param_types.class).to be(Puppet::Pops::Types::PTupleType)
         expect(t1.param_types.types).to eql([tf.numeric(), tf.numeric()])
         expect(t1.block_type).to be_nil
         t2 = t.types[1]
         expect(t2.param_types.class).to be(Puppet::Pops::Types::PTupleType)
         expect(t2.param_types.types).to eql([tf.string(), tf.string()])
         expect(t2.block_type).to be_nil
       end
     end
 
     context 'supports lambdas' do
       it 'such that, a required block can be defined and given as an argument' do
-        # use a Function as callable
-        the_callable = create_min_function_class().new(:closure_scope, :loader)
         the_function = create_function_with_required_block_all_defaults().new(:closure_scope, :loader)
-        result = the_function.call({}, 10, the_callable)
-        expect(result).to be(the_callable)
+        result = the_function.call({}, 7) { |a,b| a < b ? a : b }
+        expect(result).to eq(7)
       end
 
       it 'such that, a missing required block when called raises an error' do
-        # use a Function as callable
         the_function = create_function_with_required_block_all_defaults().new(:closure_scope, :loader)
         expect do
           the_function.call({}, 10)
         end.to raise_error(ArgumentError,
 "function 'test' called with mis-matched arguments
 expected:
   test(Integer x, Callable block) - arg count {2}
 actual:
   test(Integer) - arg count {1}")
       end
 
       it 'such that, an optional block can be defined and given as an argument' do
-        # use a Function as callable
-        the_callable = create_min_function_class().new(:closure_scope, :loader)
         the_function = create_function_with_optional_block_all_defaults().new(:closure_scope, :loader)
-        result = the_function.call({}, 10, the_callable)
-        expect(result).to be(the_callable)
+        result = the_function.call({}, 4) { |a,b| a < b ? a : b }
+        expect(result).to eql(4)
       end
 
       it 'such that, an optional block can be omitted when called and gets the value nil' do
-        # use a Function as callable
         the_function = create_function_with_optional_block_all_defaults().new(:closure_scope, :loader)
-        expect(the_function.call({}, 10)).to be_nil
+        expect(the_function.call({}, 2)).to be_nil
       end
 
       it 'such that, a scope can be injected and a block can be used' do
-        # use a Function as callable
-        the_callable = create_min_function_class().new(:closure_scope, :loader)
         the_function = create_function_with_scope_required_block_all_defaults().new(:closure_scope, :loader)
-        expect(the_function.call({}, 10, the_callable)).to be(the_callable)
+        expect(the_function.call({}, 1) { |a,b| a < b ? a : b }).to eql(1)
       end
     end
 
     context 'provides signature information' do
       it 'about capture rest (varargs)' do
         fc = create_function_with_optionals_and_varargs
         signatures = fc.signatures
         expect(signatures.size).to eql(1)
         signature = signatures[0]
         expect(signature.last_captures_rest?).to be_true
       end
 
       it 'about optional and required parameters' do
         fc = create_function_with_optionals_and_varargs
         signature = fc.signatures[0]
         expect(signature.args_range).to eql( [2, Puppet::Pops::Types::INFINITY ] )
         expect(signature.infinity?(signature.args_range[1])).to be_true
       end
 
       it 'about block not being allowed' do
         fc = create_function_with_optionals_and_varargs
         signature = fc.signatures[0]
         expect(signature.block_range).to eql( [ 0, 0 ] )
         expect(signature.block_type).to be_nil
       end
 
       it 'about required block' do
         fc = create_function_with_required_block_all_defaults
         signature = fc.signatures[0]
         expect(signature.block_range).to eql( [ 1, 1 ] )
         expect(signature.block_type).to_not be_nil
       end
 
       it 'about optional block' do
         fc = create_function_with_optional_block_all_defaults
         signature = fc.signatures[0]
         expect(signature.block_range).to eql( [ 0, 1 ] )
         expect(signature.block_type).to_not be_nil
       end
 
       it 'about the type' do
         fc = create_function_with_optional_block_all_defaults
         signature = fc.signatures[0]
         expect(signature.type.class).to be(Puppet::Pops::Types::PCallableType)
       end
 
       # conditional on Ruby 1.8.7 which does not do parameter introspection
       if Method.method_defined?(:parameters)
         it 'about parameter names obtained from ruby introspection' do
           fc = create_min_function_class
           signature = fc.signatures[0]
           expect(signature.parameter_names).to eql(['x', 'y'])
         end
       end
 
       it 'about parameter names specified with dispatch' do
         fc = create_min_function_class_using_dispatch
         signature = fc.signatures[0]
         expect(signature.parameter_names).to eql(['a', 'b'])
       end
 
       it 'about block_name when it is *not* given in the definition' do
         # neither type, nor name
         fc = create_function_with_required_block_all_defaults
         signature = fc.signatures[0]
         expect(signature.block_name).to eql('block')
         # no name given, only type
         fc = create_function_with_required_block_given_type
         signature = fc.signatures[0]
         expect(signature.block_name).to eql('block')
       end
 
       it 'about block_name when it *is* given in the definition' do
         # neither type, nor name
         fc = create_function_with_required_block_default_type
         signature = fc.signatures[0]
         expect(signature.block_name).to eql('the_block')
         # no name given, only type
         fc = create_function_with_required_block_fully_specified
         signature = fc.signatures[0]
         expect(signature.block_name).to eql('the_block')
       end
     end
 
     context 'supports calling other functions' do
       before(:all) do
         Puppet.push_context( {:loaders => Puppet::Pops::Loaders.new(Puppet::Node::Environment.create(:testing, []))})
       end
 
       after(:all) do
         Puppet.pop_context()
       end
 
       it 'such that, other functions are callable by name' do
         fc = Puppet::Functions.create_function(:test) do
           def test()
             # Call a function available in the puppet system
             call_function('assert_type', 'Integer', 10)
           end
         end
         # initiate the function the same way the loader initiates it
         f = fc.new(:closure_scope, Puppet.lookup(:loaders).puppet_system_loader)
         expect(f.call({})).to eql(10)
       end
 
       it 'such that, calling a non existing function raises an error' do
         fc = Puppet::Functions.create_function(:test) do
           def test()
             # Call a function not available in the puppet system
             call_function('no_such_function', 'Integer', 'hello')
           end
         end
         # initiate the function the same way the loader initiates it
         f = fc.new(:closure_scope, Puppet.lookup(:loaders).puppet_system_loader)
         expect{f.call({})}.to raise_error(ArgumentError, "Function test(): cannot call function 'no_such_function' - not found")
       end
     end
 
     context 'supports calling ruby functions with lambda from puppet' do
       before(:all) do
         Puppet.push_context( {:loaders => Puppet::Pops::Loaders.new(Puppet::Node::Environment.create(:testing, []))})
       end
 
       after(:all) do
         Puppet.pop_context()
       end
 
       before(:each) do
         Puppet[:strict_variables] = true
 
         # These must be set since the is 3x logic that triggers on these even if the tests are explicit
         # about selection of parser and evaluator
         #
         Puppet[:parser] = 'future'
         # Puppetx cannot be loaded until the correct parser has been set (injector is turned off otherwise)
         require 'puppetx'
       end
 
       let(:parser) {  Puppet::Pops::Parser::EvaluatingParser.new }
       let(:node) { 'node.example.com' }
       let(:scope) { s = create_test_scope_for_node(node); s }
 
       it 'function with required block can be called' do
         # construct ruby function to call
         fc = Puppet::Functions.create_function('testing::test') do
           dispatch :test do
             param 'Integer', 'x'
             # block called 'the_block', and using "all_callables"
             required_block_param #(all_callables(), 'the_block')
           end
-          def test(x, block)
+          def test(x)
             # call the block with x
-            block.call(x)
+            yield(x)
           end
         end
         # add the function to the loader (as if it had been loaded from somewhere)
         the_loader = loader()
         f = fc.new({}, the_loader)
         loader.add_function('testing::test', f)
         # evaluate a puppet call
         source = "testing::test(10) |$x| { $x+1 }"
         program = parser.parse_string(source, __FILE__)
         Puppet::Pops::Adapters::LoaderAdapter.adapt(program.model).loader = the_loader
         expect(parser.evaluate(scope, program)).to eql(11)
       end
     end
 
   end
 
   def create_noargs_function_class
     f = Puppet::Functions.create_function('test') do
       def test()
         10
       end
     end
   end
 
   def create_min_function_class
     f = Puppet::Functions.create_function('min') do
       def min(x,y)
         x <= y ? x : y
       end
     end
   end
 
   def create_max_function_class
     f = Puppet::Functions.create_function('max') do
       def max(x,y)
         x >= y ? x : y
       end
     end
   end
 
   def create_badly_named_method_function_class
     f = Puppet::Functions.create_function('mix') do
       def mix_up(x,y)
         x <= y ? x : y
       end
     end
   end
 
   def create_min_function_class_using_dispatch
     f = Puppet::Functions.create_function('min') do
         dispatch :min do
           param 'Numeric', 'a'
           param 'Numeric', 'b'
         end
       def min(x,y)
         x <= y ? x : y
       end
     end
   end
 
   def create_min_function_class_disptaching_to_two_methods
     f = Puppet::Functions.create_function('min') do
       dispatch :min do
         param 'Numeric', 'a'
         param 'Numeric', 'b'
       end
 
       dispatch :min_s do
         param 'String', 's1'
         param 'String', 's2'
       end
 
       def min(x,y)
         x <= y ? x : y
       end
 
       def min_s(x,y)
         cmp = (x.downcase <=> y.downcase)
         cmp <= 0 ? x : y
       end
     end
   end
 
   def create_function_with_optionals_and_varargs
     f = Puppet::Functions.create_function('min') do
       def min(x,y,a=1, b=1, *c)
         x <= y ? x : y
       end
     end
   end
 
   def create_function_with_optionals_and_varargs_via_dispatch
     f = Puppet::Functions.create_function('min') do
       dispatch :min do
         param 'Numeric', 'x'
         param 'Numeric', 'y'
         param 'Numeric', 'a'
         param 'Numeric', 'b'
         param 'Numeric', 'c'
         arg_count 2, :default
       end
       def min(x,y,a=1, b=1, *c)
         x <= y ? x : y
       end
     end
   end
 
   def create_function_with_class_injection
     f = Puppet::Functions.create_function('test', Puppet::Functions::InternalFunction) do
       attr_injected Puppet::Pops::Types::TypeFactory.type_of(FunctionAPISpecModule::TestDuck), :test_attr
       attr_injected Puppet::Pops::Types::TypeFactory.string(), :test_attr2, "a_string"
       attr_injected_producer Puppet::Pops::Types::TypeFactory.integer(), :serial, "an_int"
 
       def test(x,y,a=1, b=1, *c)
         x <= y ? x : y
       end
     end
   end
 
   def create_function_with_param_injection_regular
     f = Puppet::Functions.create_function('test', Puppet::Functions::InternalFunction) do
       attr_injected Puppet::Pops::Types::TypeFactory.type_of(FunctionAPISpecModule::TestDuck), :test_attr
       attr_injected Puppet::Pops::Types::TypeFactory.string(), :test_attr2, "a_string"
       attr_injected_producer Puppet::Pops::Types::TypeFactory.integer(), :serial, "an_int"
 
       dispatch :test do
         injected_param Puppet::Pops::Types::TypeFactory.string, 'x', 'a_string'
         injected_producer_param Puppet::Pops::Types::TypeFactory.integer, 'y', 'an_int'
         param 'Scalar', 'a'
         param 'Scalar', 'b'
       end
 
       def test(x,y,a,b)
         y_produced = y.produce(nil)
         "#{x}! #{a}, and #{b} < #{y_produced} = #{ !!(a < y_produced && b < y_produced)}"
       end
     end
   end
 
   def create_function_with_required_block_all_defaults
     f = Puppet::Functions.create_function('test') do
       dispatch :test do
         param 'Integer', 'x'
         # use defaults, any callable, name is 'block'
         required_block_param
       end
-      def test(x, block)
-        # returns the block to make it easy to test what it got when called
-        block
+      def test(x)
+        yield(8,x)
       end
     end
   end
 
   def create_function_with_scope_required_block_all_defaults
     f = Puppet::Functions.create_function('test', Puppet::Functions::InternalFunction) do
       dispatch :test do
         scope_param
         param 'Integer', 'x'
         # use defaults, any callable, name is 'block'
         required_block_param
       end
-      def test(scope, x, block)
-        # returns the block to make it easy to test what it got when called
-        block
+      def test(scope, x)
+        yield(3,x)
       end
     end
   end
 
   def create_function_with_required_block_default_type
     f = Puppet::Functions.create_function('test') do
       dispatch :test do
         param 'Integer', 'x'
         # use defaults, any callable, name is 'block'
         required_block_param 'the_block'
       end
-      def test(x, block)
-        # returns the block to make it easy to test what it got when called
-        block
+      def test(x)
+        yield
       end
     end
   end
 
   def create_function_with_required_block_given_type
     f = Puppet::Functions.create_function('test') do
       dispatch :test do
         param 'Integer', 'x'
         required_block_param
       end
-      def test(x, block)
-        # returns the block to make it easy to test what it got when called
-        block
+      def test(x)
+        yield
       end
     end
   end
 
   def create_function_with_required_block_fully_specified
     f = Puppet::Functions.create_function('test') do
       dispatch :test do
         param 'Integer', 'x'
         # use defaults, any callable, name is 'block'
         required_block_param('Callable', 'the_block')
       end
-      def test(x, block)
-        # returns the block to make it easy to test what it got when called
-        block
+      def test(x)
+        yield
       end
     end
   end
 
   def create_function_with_optional_block_all_defaults
     f = Puppet::Functions.create_function('test') do
       dispatch :test do
         param 'Integer', 'x'
         # use defaults, any callable, name is 'block'
         optional_block_param
       end
-      def test(x, block=nil)
-        # returns the block to make it easy to test what it got when called
-        # a default of nil must be used or the call will fail with a missing parameter
-        block
+      def test(x)
+        yield(5,x) if block_given?
       end
     end
   end
 
 end
diff --git a/spec/unit/pops/evaluator/evaluating_parser_spec.rb b/spec/unit/pops/evaluator/evaluating_parser_spec.rb
index 99c232aa9..e22e1342f 100644
--- a/spec/unit/pops/evaluator/evaluating_parser_spec.rb
+++ b/spec/unit/pops/evaluator/evaluating_parser_spec.rb
@@ -1,1337 +1,1337 @@
 require 'spec_helper'
 
 require 'puppet/pops'
 require 'puppet/pops/evaluator/evaluator_impl'
 require 'puppet/loaders'
 require 'puppet_spec/pops'
 require 'puppet_spec/scope'
 require 'puppet/parser/e4_parser_adapter'
 
 
 # relative to this spec file (./) does not work as this file is loaded by rspec
 #require File.join(File.dirname(__FILE__), '/evaluator_rspec_helper')
 
 describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
   include PuppetSpec::Pops
   include PuppetSpec::Scope
   before(:each) do
     Puppet[:strict_variables] = true
 
     # These must be set since the 3x logic switches some behaviors on these even if the tests explicitly
     # use the 4x parser and evaluator.
     #
     Puppet[:parser] = 'future'
 
     # Puppetx cannot be loaded until the correct parser has been set (injector is turned off otherwise)
     require 'puppetx'
 
     # Tests needs a known configuration of node/scope/compiler since it parses and evaluates
     # snippets as the compiler will evaluate them, butwithout the overhead of compiling a complete
     # catalog for each tested expression.
     #
     @parser  = Puppet::Pops::Parser::EvaluatingParser.new
     @node = Puppet::Node.new('node.example.com')
     @node.environment = Puppet::Node::Environment.create(:testing, [])
     @compiler = Puppet::Parser::Compiler.new(@node)
     @scope = Puppet::Parser::Scope.new(@compiler)
     @scope.source = Puppet::Resource::Type.new(:node, 'node.example.com')
     @scope.parent = @compiler.topscope
   end
 
   let(:parser) {  @parser }
   let(:scope) { @scope }
   types = Puppet::Pops::Types::TypeFactory
 
   context "When evaluator evaluates literals" do
     {
       "1"             => 1,
       "010"           => 8,
       "0x10"          => 16,
       "3.14"          => 3.14,
       "0.314e1"       => 3.14,
       "31.4e-1"       => 3.14,
       "'1'"           => '1',
       "'banana'"      => 'banana',
       '"banana"'      => 'banana',
       "banana"        => 'banana',
       "banana::split" => 'banana::split',
       "false"         => false,
       "true"          => true,
       "Array"         => types.array_of_data(),
       "/.*/"          => /.*/
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           parser.evaluate_string(scope, source, __FILE__).should == result
         end
       end
   end
 
   context "When the evaluator evaluates Lists and Hashes" do
     {
       "[]"                                              => [],
       "[1,2,3]"                                         => [1,2,3],
       "[1,[2.0, 2.1, [2.2]],[3.0, 3.1]]"                => [1,[2.0, 2.1, [2.2]],[3.0, 3.1]],
       "[2 + 2]"                                         => [4],
       "[1,2,3] == [1,2,3]"                              => true,
       "[1,2,3] != [2,3,4]"                              => true,
       "[1,2,3] == [2,2,3]"                              => false,
       "[1,2,3] != [1,2,3]"                              => false,
       "[1,2,3][2]"                                      => 3,
       "[1,2,3] + [4,5]"                                 => [1,2,3,4,5],
       "[1,2,3] + [[4,5]]"                               => [1,2,3,[4,5]],
       "[1,2,3] + 4"                                     => [1,2,3,4],
       "[1,2,3] << [4,5]"                                => [1,2,3,[4,5]],
       "[1,2,3] << {'a' => 1, 'b'=>2}"                   => [1,2,3,{'a' => 1, 'b'=>2}],
       "[1,2,3] << 4"                                    => [1,2,3,4],
       "[1,2,3,4] - [2,3]"                               => [1,4],
       "[1,2,3,4] - [2,5]"                               => [1,3,4],
       "[1,2,3,4] - 2"                                   => [1,3,4],
       "[1,2,3,[2],4] - 2"                               => [1,3,[2],4],
       "[1,2,3,[2,3],4] - [[2,3]]"                       => [1,2,3,4],
       "[1,2,3,3,2,4,2,3] - [2,3]"                       => [1,4],
       "[1,2,3,['a',1],['b',2]] - {'a' => 1, 'b'=>2}"    => [1,2,3],
       "[1,2,3,{'a'=>1,'b'=>2}] - [{'a' => 1, 'b'=>2}]"  => [1,2,3],
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           parser.evaluate_string(scope, source, __FILE__).should == result
         end
       end
 
     {
       "[1,2,3] + {'a' => 1, 'b'=>2}"                    => [1,2,3,['a',1],['b',2]],
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           # This test must be done with match_array since the order of the hash
           # is undefined and Ruby 1.8.7 and 1.9.3 produce different results.
           expect(parser.evaluate_string(scope, source, __FILE__)).to match_array(result)
         end
       end
 
     {
       "[1,2,3][a]" => :error,
     }.each do |source, result|
         it "should parse and raise error for '#{source}'" do
           expect { parser.evaluate_string(scope, source, __FILE__) }.to raise_error(Puppet::ParseError)
         end
       end
 
     {
       "{}"                                       => {},
       "{'a'=>1,'b'=>2}"                          => {'a'=>1,'b'=>2},
       "{'a'=>1,'b'=>{'x'=>2.1,'y'=>2.2}}"        => {'a'=>1,'b'=>{'x'=>2.1,'y'=>2.2}},
       "{'a'=> 2 + 2}"                            => {'a'=> 4},
       "{'a'=> 1, 'b'=>2} == {'a'=> 1, 'b'=>2}"   => true,
       "{'a'=> 1, 'b'=>2} != {'x'=> 1, 'b'=>2}"   => true,
       "{'a'=> 1, 'b'=>2} == {'a'=> 2, 'b'=>3}"   => false,
       "{'a'=> 1, 'b'=>2} != {'a'=> 1, 'b'=>2}"   => false,
       "{a => 1, b => 2}[b]"                      => 2,
       "{2+2 => sum, b => 2}[4]"                  => 'sum',
       "{'a'=>1, 'b'=>2} + {'c'=>3}"              => {'a'=>1,'b'=>2,'c'=>3},
       "{'a'=>1, 'b'=>2} + {'b'=>3}"              => {'a'=>1,'b'=>3},
       "{'a'=>1, 'b'=>2} + ['c', 3, 'b', 3]"      => {'a'=>1,'b'=>3, 'c'=>3},
       "{'a'=>1, 'b'=>2} + [['c', 3], ['b', 3]]"  => {'a'=>1,'b'=>3, 'c'=>3},
       "{'a'=>1, 'b'=>2} - {'b' => 3}"            => {'a'=>1},
       "{'a'=>1, 'b'=>2, 'c'=>3} - ['b', 'c']"    => {'a'=>1},
       "{'a'=>1, 'b'=>2, 'c'=>3} - 'c'"           => {'a'=>1, 'b'=>2},
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           parser.evaluate_string(scope, source, __FILE__).should == result
         end
       end
 
     {
       "{'a' => 1, 'b'=>2} << 1" => :error,
     }.each do |source, result|
         it "should parse and raise error for '#{source}'" do
           expect { parser.evaluate_string(scope, source, __FILE__) }.to raise_error(Puppet::ParseError)
         end
       end
   end
 
   context "When the evaluator perform comparisons" do
     {
       "'a' == 'a'"     => true,
       "'a' == 'b'"     => false,
       "'a' != 'a'"     => false,
       "'a' != 'b'"     => true,
       "'a' < 'b' "     => true,
       "'a' < 'a' "     => false,
       "'b' < 'a' "     => false,
       "'a' <= 'b'"     => true,
       "'a' <= 'a'"     => true,
       "'b' <= 'a'"     => false,
       "'a' > 'b' "     => false,
       "'a' > 'a' "     => false,
       "'b' > 'a' "     => true,
       "'a' >= 'b'"     => false,
       "'a' >= 'a'"     => true,
       "'b' >= 'a'"     => true,
       "'a' == 'A'"     => true,
       "'a' != 'A'"     => false,
       "'a' >  'A'"     => false,
       "'a' >= 'A'"     => true,
       "'A' <  'a'"     => false,
       "'A' <= 'a'"     => true,
       "1 == 1"         => true,
       "1 == 2"         => false,
       "1 != 1"         => false,
       "1 != 2"         => true,
       "1 < 2 "         => true,
       "1 < 1 "         => false,
       "2 < 1 "         => false,
       "1 <= 2"         => true,
       "1 <= 1"         => true,
       "2 <= 1"         => false,
       "1 > 2 "         => false,
       "1 > 1 "         => false,
       "2 > 1 "         => true,
       "1 >= 2"         => false,
       "1 >= 1"         => true,
       "2 >= 1"         => true,
       "1 == 1.0 "      => true,
       "1 < 1.1  "      => true,
       "1.0 == 1 "      => true,
       "1.0 < 2  "      => true,
       "'1.0' < 'a'"    => true,
       "'1.0' < '' "    => false,
       "'1.0' < ' '"    => false,
       "'a' > '1.0'"    => true,
       "/.*/ == /.*/ "  => true,
       "/.*/ != /a.*/"  => true,
       "true  == true " => true,
       "false == false" => true,
       "true == false"  => false,
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           parser.evaluate_string(scope, source, __FILE__).should == result
         end
       end
 
    {
      "a > 1" => /String > Integer/,
      "a >= 1" => /String >= Integer/,
      "a < 1" => /String < Integer/,
      "a <= 1" => /String <= Integer/,
      "1 > a" => /Integer > String/,
      "1 >= a" => /Integer >= String/,
      "1 < a" => /Integer < String/,
      "1 <= a" => /Integer <= String/,
    }.each do | source, error|
      it "should not allow comparison of String and Number '#{source}'" do
        expect { parser.evaluate_string(scope, source, __FILE__)}.to raise_error(error)
      end
    end
 
    {
       "'a' =~ /.*/"                     => true,
       "'a' =~ '.*'"                     => true,
       "/.*/ != /a.*/"                   => true,
       "'a' !~ /b.*/"                    => true,
       "'a' !~ 'b.*'"                    => true,
       '$x = a; a =~ "$x.*"'             => true,
       "a =~ Pattern['a.*']"             => true,
       "a =~ Regexp['a.*']"              => false, # String is not subtype of Regexp. PUP-957
       "$x = /a.*/ a =~ $x"              => true,
       "$x = Pattern['a.*'] a =~ $x"     => true,
       "1 =~ Integer"                    => true,
       "1 !~ Integer"                    => false,
       "[1,2,3] =~ Array[Integer[1,10]]" => true,
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           parser.evaluate_string(scope, source, __FILE__).should == result
         end
       end
 
     {
       "666 =~ /6/"    => :error,
       "[a] =~ /a/"    => :error,
       "{a=>1} =~ /a/" => :error,
        "/a/ =~ /a/"    => :error,
       "Array =~ /A/"  => :error,
     }.each do |source, result|
         it "should parse and raise error for '#{source}'" do
           expect { parser.evaluate_string(scope, source, __FILE__) }.to raise_error(Puppet::ParseError)
         end
       end
 
     {
       "1 in [1,2,3]"                  => true,
       "4 in [1,2,3]"                  => false,
       "a in {x=>1, a=>2}"             => true,
       "z in {x=>1, a=>2}"             => false,
       "ana in bananas"                => true,
       "xxx in bananas"                => false,
       "/ana/ in bananas"              => true,
       "/xxx/ in bananas"              => false,
       "ANA in bananas"                => false, # ANA is a type, not a String
       "String[1] in bananas"          => false, # Philosophically true though :-)
       "'ANA' in bananas"              => true,
       "ana in 'BANANAS'"              => true,
       "/ana/ in 'BANANAS'"            => false,
       "/ANA/ in 'BANANAS'"            => true,
       "xxx in 'BANANAS'"              => false,
       "[2,3] in [1,[2,3],4]"          => true,
       "[2,4] in [1,[2,3],4]"          => false,
       "[a,b] in ['A',['A','B'],'C']"  => true,
       "[x,y] in ['A',['A','B'],'C']"  => false,
       "a in {a=>1}"                   => true,
       "x in {a=>1}"                   => false,
       "'A' in {a=>1}"                 => true,
       "'X' in {a=>1}"                 => false,
       "a in {'A'=>1}"                 => true,
       "x in {'A'=>1}"                 => false,
       "/xxx/ in {'aaaxxxbbb'=>1}"     => true,
       "/yyy/ in {'aaaxxxbbb'=>1}"     => false,
       "15 in [1, 0xf]"                => true,
       "15 in [1, '0xf']"              => false,
       "'15' in [1, 0xf]"              => false,
       "15 in [1, 115]"                => false,
       "1 in [11, '111']"              => false,
       "'1' in [11, '111']"            => false,
       "Array[Integer] in [2, 3]"      => false,
       "Array[Integer] in [2, [3, 4]]" => true,
       "Array[Integer] in [2, [a, 4]]" => false,
       "Integer in { 2 =>'a'}"         => true,
       "Integer[5,10] in [1,5,3]"      => true,
       "Integer[5,10] in [1,2,3]"      => false,
       "Integer in {'a'=>'a'}"         => false,
       "Integer in {'a'=>1}"           => false,
     }.each do |source, result|
       it "should parse and evaluate the expression '#{source}' to #{result}" do
         parser.evaluate_string(scope, source, __FILE__).should == result
       end
     end
 
     {
       "if /(ana)/ in bananas {$1}" => 'ana',
       "if /(xyz)/ in bananas {$1} else {$1}" => nil,
       "$a = bananas =~ /(ana)/; $b = /(xyz)/ in bananas; $1" => 'ana',
       "$a = xyz =~ /(xyz)/; $b = /(ana)/ in bananas; $1" => 'ana',
       "if /p/ in [pineapple, bananas] {$0}" => 'p',
       "if /b/ in [pineapple, bananas] {$0}" => 'b',
     }.each do |source, result|
       it "sets match variables for a regexp search using in such that '#{source}' produces '#{result}'" do
           parser.evaluate_string(scope, source, __FILE__).should == result
       end
     end
 
     {
       'Any'  => ['Data', 'Scalar', 'Numeric', 'Integer', 'Float', 'Boolean', 'String', 'Pattern', 'Collection',
                     'Array', 'Hash', 'CatalogEntry', 'Resource', 'Class', 'Undef', 'File', 'NotYetKnownResourceType'],
 
       # Note, Data > Collection is false (so not included)
       'Data'    => ['Scalar', 'Numeric', 'Integer', 'Float', 'Boolean', 'String', 'Pattern', 'Array', 'Hash',],
       'Scalar' => ['Numeric', 'Integer', 'Float', 'Boolean', 'String', 'Pattern'],
       'Numeric' => ['Integer', 'Float'],
       'CatalogEntry' => ['Class', 'Resource', 'File', 'NotYetKnownResourceType'],
       'Integer[1,10]' => ['Integer[2,3]'],
     }.each do |general, specials|
       specials.each do |special |
         it "should compute that #{general} > #{special}" do
           parser.evaluate_string(scope, "#{general} > #{special}", __FILE__).should == true
         end
         it "should compute that  #{special} < #{general}" do
           parser.evaluate_string(scope, "#{special} < #{general}", __FILE__).should == true
         end
         it "should compute that #{general} != #{special}" do
           parser.evaluate_string(scope, "#{special} != #{general}", __FILE__).should == true
         end
       end
     end
 
     {
       'Integer[1,10] > Integer[2,3]'   => true,
       'Integer[1,10] == Integer[2,3]'  => false,
       'Integer[1,10] > Integer[0,5]'   => false,
       'Integer[1,10] > Integer[1,10]'  => false,
       'Integer[1,10] >= Integer[1,10]' => true,
       'Integer[1,10] == Integer[1,10]' => true,
     }.each do |source, result|
         it "should parse and evaluate the integer range comparison expression '#{source}' to #{result}" do
           parser.evaluate_string(scope, source, __FILE__).should == result
         end
       end
 
   end
 
   context "When the evaluator performs arithmetic" do
     context "on Integers" do
       {  "2+2"    => 4,
          "2 + 2"  => 4,
          "7 - 3"  => 4,
          "6 * 3"  => 18,
          "6 / 3"  => 2,
          "6 % 3"  => 0,
          "10 % 3" =>  1,
          "-(6/3)" => -2,
          "-6/3  " => -2,
          "8 >> 1" => 4,
          "8 << 1" => 16,
       }.each do |source, result|
           it "should parse and evaluate the expression '#{source}' to #{result}" do
             parser.evaluate_string(scope, source, __FILE__).should == result
           end
         end
 
     context "on Floats" do
       {
         "2.2 + 2.2"  => 4.4,
         "7.7 - 3.3"  => 4.4,
         "6.1 * 3.1"  => 18.91,
         "6.6 / 3.3"  => 2.0,
         "-(6.0/3.0)" => -2.0,
         "-6.0/3.0 "  => -2.0,
       }.each do |source, result|
           it "should parse and evaluate the expression '#{source}' to #{result}" do
             parser.evaluate_string(scope, source, __FILE__).should == result
           end
         end
 
       {
         "3.14 << 2" => :error,
         "3.14 >> 2" => :error,
         "6.6 % 3.3"  => 0.0,
         "10.0 % 3.0" =>  1.0,
       }.each do |source, result|
           it "should parse and raise error for '#{source}'" do
             expect { parser.evaluate_string(scope, source, __FILE__) }.to raise_error(Puppet::ParseError)
           end
         end
     end
 
     context "on strings requiring boxing to Numeric" do
       {
         "'2' + '2'"       => 4,
         "'-2' + '2'"      => 0,
         "'- 2' + '2'"     => 0,
         '"-\t 2" + "2"'   => 0,
         "'+2' + '2'"      => 4,
         "'+ 2' + '2'"     => 4,
         "'2.2' + '2.2'"   => 4.4,
         "'-2.2' + '2.2'"  => 0.0,
         "'0xF7' + '010'"  => 0xFF,
         "'0xF7' + '0x8'"  => 0xFF,
         "'0367' + '010'"  => 0xFF,
         "'012.3' + '010'" => 20.3,
         "'-0x2' + '0x4'"  => 2,
         "'+0x2' + '0x4'"  => 6,
         "'-02' + '04'"    => 2,
         "'+02' + '04'"    => 6,
       }.each do |source, result|
           it "should parse and evaluate the expression '#{source}' to #{result}" do
             parser.evaluate_string(scope, source, __FILE__).should == result
           end
         end
 
       {
         "'0888' + '010'"   => :error,
         "'0xWTF' + '010'"  => :error,
         "'0x12.3' + '010'" => :error,
         "'0x12.3' + '010'" => :error,
         '"-\n 2" + "2"'    => :error,
         '"-\v 2" + "2"'    => :error,
         '"-2\n" + "2"'     => :error,
         '"-2\n " + "2"'    => :error,
       }.each do |source, result|
           it "should parse and raise error for '#{source}'" do
             expect { parser.evaluate_string(scope, source, __FILE__) }.to raise_error(Puppet::ParseError)
           end
         end
       end
     end
   end # arithmetic
 
   context "When the evaluator evaluates assignment" do
     {
       "$a = 5"                     => 5,
       "$a = 5; $a"                 => 5,
       "$a = 5; $b = 6; $a"         => 5,
       "$a = $b = 5; $a == $b"      => true,
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           parser.evaluate_string(scope, source, __FILE__).should == result
         end
       end
 
     {
       "[a,b,c] = [1,2,3]"               => /attempt to assign to 'an Array Expression'/,
       "[a,b,c] = {b=>2,c=>3,a=>1}"      => /attempt to assign to 'an Array Expression'/,
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to error with #{result}" do
           expect { parser.evaluate_string(scope, source, __FILE__)}.to raise_error(Puppet::ParseError, result)
         end
       end
   end
 
   context "When the evaluator evaluates conditionals" do
     {
       "if true {5}"                     => 5,
       "if false {5}"                    => nil,
       "if false {2} else {5}"           => 5,
       "if false {2} elsif true {5}"     => 5,
       "if false {2} elsif false {5}"    => nil,
       "unless false {5}"                => 5,
       "unless true {5}"                 => nil,
       "unless true {2} else {5}"        => 5,
       "$a = if true {5} $a"                     => 5,
       "$a = if false {5} $a"                    => nil,
       "$a = if false {2} else {5} $a"           => 5,
       "$a = if false {2} elsif true {5} $a"     => 5,
       "$a = if false {2} elsif false {5} $a"    => nil,
       "$a = unless false {5} $a"                => 5,
       "$a = unless true {5} $a"                 => nil,
       "$a = unless true {2} else {5} $a"        => 5,
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           parser.evaluate_string(scope, source, __FILE__).should == result
         end
       end
 
     {
       "case 1 { 1 : { yes } }"                               => 'yes',
       "case 2 { 1,2,3 : { yes} }"                            => 'yes',
       "case 2 { 1,3 : { no } 2: { yes} }"                    => 'yes',
       "case 2 { 1,3 : { no } 5: { no } default: { yes }}"    => 'yes',
       "case 2 { 1,3 : { no } 5: { no } }"                    => nil,
       "case 'banana' { 1,3 : { no } /.*ana.*/: { yes } }"    => 'yes',
       "case 'banana' { /.*(ana).*/: { $1 } }"                => 'ana',
       "case [1] { Array : { yes } }"                         => 'yes',
       "case [1] {
          Array[String] : { no }
          Array[Integer]: { yes }
       }"                                                     => 'yes',
       "case 1 {
          Integer : { yes }
          Type[Integer] : { no } }"                           => 'yes',
       "case Integer {
          Integer : { no }
          Type[Integer] : { yes } }"                          => 'yes',
       # supports unfold
       "case ringo {
          *[paul, john, ringo, george] : { 'beatle' } }"       => 'beatle',
 
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           parser.evaluate_string(scope, source, __FILE__).should == result
         end
       end
 
     {
       "2 ? { 1 => no, 2 => yes}"                          => 'yes',
       "3 ? { 1 => no, 2 => no, default => yes }"          => 'yes',
       "3 ? { 1 => no, default => yes, 3 => no }"          => 'no',
       "3 ? { 1 => no, 3 => no, default => yes }"          => 'no',
       "4 ? { 1 => no, default => yes, 3 => no }"          => 'yes',
       "4 ? { 1 => no, 3 => no, default => yes }"          => 'yes',
       "'banana' ? { /.*(ana).*/  => $1 }"                 => 'ana',
       "[2] ? { Array[String] => yes, Array => yes}"       => 'yes',
       "ringo ? *[paul, john, ringo, george] => 'beatle'"  => 'beatle',
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           parser.evaluate_string(scope, source, __FILE__).should == result
         end
       end
 
     it 'fails if a selector does not match' do
       expect{parser.evaluate_string(scope, "2 ? 3 => 4")}.to raise_error(/No matching entry for selector parameter with value '2'/)
     end
   end
 
   context "When evaluator evaluated unfold" do
     {
       "*[1,2,3]"             => [1,2,3],
       "*1"                   => [1],
       "*'a'"                 => ['a']
     }.each do |source, result|
       it "should parse and evaluate the expression '#{source}' to #{result}" do
         parser.evaluate_string(scope, source, __FILE__).should == result
       end
     end
 
     it "should parse and evaluate the expression '*{a=>10, b=>20} to [['a',10],['b',20]]" do
       result = parser.evaluate_string(scope, '*{a=>10, b=>20}', __FILE__)
       expect(result).to include(['a', 10])
       expect(result).to include(['b', 20])
     end
 
   end
 
   context "When evaluator performs [] operations" do
     {
       "[1,2,3][0]"      => 1,
       "[1,2,3][2]"      => 3,
       "[1,2,3][3]"      => nil,
       "[1,2,3][-1]"     => 3,
       "[1,2,3][-2]"     => 2,
       "[1,2,3][-4]"     => nil,
       "[1,2,3,4][0,2]"  => [1,2],
       "[1,2,3,4][1,3]"  => [2,3,4],
       "[1,2,3,4][-2,2]"  => [3,4],
       "[1,2,3,4][-3,2]"  => [2,3],
       "[1,2,3,4][3,5]"   => [4],
       "[1,2,3,4][5,2]"   => [],
       "[1,2,3,4][0,-1]"  => [1,2,3,4],
       "[1,2,3,4][0,-2]"  => [1,2,3],
       "[1,2,3,4][0,-4]"  => [1],
       "[1,2,3,4][0,-5]"  => [],
       "[1,2,3,4][-5,2]"  => [1],
       "[1,2,3,4][-5,-3]" => [1,2],
       "[1,2,3,4][-6,-3]" => [1,2],
       "[1,2,3,4][2,-3]"  => [],
       "[1,*[2,3],4]"     => [1,2,3,4],
       "[1,*[2,3],4][1]"  => 2,
     }.each do |source, result|
       it "should parse and evaluate the expression '#{source}' to #{result}" do
         parser.evaluate_string(scope, source, __FILE__).should == result
       end
     end
 
     {
       "{a=>1, b=>2, c=>3}[a]"                => 1,
       "{a=>1, b=>2, c=>3}[c]"                => 3,
       "{a=>1, b=>2, c=>3}[x]"                => nil,
       "{a=>1, b=>2, c=>3}[c,b]"              => [3,2],
       "{a=>1, b=>2, c=>3}[a,b,c]"            => [1,2,3],
       "{a=>{b=>{c=>'it works'}}}[a][b][c]"   => 'it works',
       "$a = {undef => 10} $a[free_lunch]"     => nil,
       "$a = {undef => 10} $a[undef]"          => 10,
       "$a = {undef => 10} $a[$a[free_lunch]]" => 10,
       "$a = {} $a[free_lunch] == undef"       => true,
     }.each do |source, result|
       it "should parse and evaluate the expression '#{source}' to #{result}" do
         parser.evaluate_string(scope, source, __FILE__).should == result
       end
     end
 
     {
       "'abc'[0]"      => 'a',
       "'abc'[2]"      => 'c',
       "'abc'[-1]"     => 'c',
       "'abc'[-2]"     => 'b',
       "'abc'[-3]"     => 'a',
       "'abc'[-4]"     => '',
       "'abc'[3]"      => '',
       "abc[0]"        => 'a',
       "abc[2]"        => 'c',
       "abc[-1]"       => 'c',
       "abc[-2]"       => 'b',
       "abc[-3]"       => 'a',
       "abc[-4]"       => '',
       "abc[3]"        => '',
       "'abcd'[0,2]"   => 'ab',
       "'abcd'[1,3]"   => 'bcd',
       "'abcd'[-2,2]"  => 'cd',
       "'abcd'[-3,2]"  => 'bc',
       "'abcd'[3,5]"   => 'd',
       "'abcd'[5,2]"   => '',
       "'abcd'[0,-1]"  => 'abcd',
       "'abcd'[0,-2]"  => 'abc',
       "'abcd'[0,-4]"  => 'a',
       "'abcd'[0,-5]"  => '',
       "'abcd'[-5,2]"  => 'a',
       "'abcd'[-5,-3]" => 'ab',
       "'abcd'[-6,-3]" => 'ab',
       "'abcd'[2,-3]"  => '',
    }.each do |source, result|
       it "should parse and evaluate the expression '#{source}' to #{result}" do
         parser.evaluate_string(scope, source, __FILE__).should == result
       end
     end
 
     # Type operations (full set tested by tests covering type calculator)
     {
       "Array[Integer]"                  => types.array_of(types.integer),
       "Array[Integer,1]"                => types.constrain_size(types.array_of(types.integer),1, :default),
       "Array[Integer,1,2]"              => types.constrain_size(types.array_of(types.integer),1, 2),
       "Array[Integer,Integer[1,2]]"     => types.constrain_size(types.array_of(types.integer),1, 2),
       "Array[Integer,Integer[1]]"       => types.constrain_size(types.array_of(types.integer),1, :default),
       "Hash[Integer,Integer]"           => types.hash_of(types.integer, types.integer),
       "Hash[Integer,Integer,1]"         => types.constrain_size(types.hash_of(types.integer, types.integer),1, :default),
       "Hash[Integer,Integer,1,2]"       => types.constrain_size(types.hash_of(types.integer, types.integer),1, 2),
       "Hash[Integer,Integer,Integer[1,2]]" => types.constrain_size(types.hash_of(types.integer, types.integer),1, 2),
       "Hash[Integer,Integer,Integer[1]]"   => types.constrain_size(types.hash_of(types.integer, types.integer),1, :default),
       "Resource[File]"                  => types.resource('File'),
       "Resource['File']"                => types.resource(types.resource('File')),
       "File[foo]"                       => types.resource('file', 'foo'),
       "File[foo, bar]"                  => [types.resource('file', 'foo'), types.resource('file', 'bar')],
       "Pattern[a, /b/, Pattern[c], Regexp[d]]"  => types.pattern('a', 'b', 'c', 'd'),
       "String[1,2]"                     => types.constrain_size(types.string,1, 2),
       "String[Integer[1,2]]"            => types.constrain_size(types.string,1, 2),
       "String[Integer[1]]"              => types.constrain_size(types.string,1, :default),
     }.each do |source, result|
       it "should parse and evaluate the expression '#{source}' to #{result}" do
         parser.evaluate_string(scope, source, __FILE__).should == result
       end
     end
 
     # LHS where [] not supported, and missing key(s)
     {
       "Array[]"                    => :error,
       "'abc'[]"                    => :error,
       "Resource[]"                 => :error,
       "File[]"                     => :error,
       "String[]"                   => :error,
       "1[]"                        => :error,
       "3.14[]"                     => :error,
       "/.*/[]"                     => :error,
       "$a=[1] $a[]"                => :error,
     }.each do |source, result|
       it "should parse and evaluate the expression '#{source}' to #{result}" do
         expect { parser.evaluate_string(scope, source, __FILE__)}.to raise_error(/Syntax error/)
       end
     end
 
     # Errors when wrong number/type of keys are used
     {
       "Array[0]"                    => 'Array-Type[] arguments must be types. Got Fixnum',
       "Hash[0]"                     => 'Hash-Type[] arguments must be types. Got Fixnum',
       "Hash[Integer, 0]"            => 'Hash-Type[] arguments must be types. Got Fixnum',
       "Array[Integer,1,2,3]"        => 'Array-Type[] accepts 1 to 3 arguments. Got 4',
       "Array[Integer,String]"       => "A Type's size constraint arguments must be a single Integer type, or 1-2 integers (or default). Got a String-Type",
       "Hash[Integer,String, 1,2,3]" => 'Hash-Type[] accepts 2 to 4 arguments. Got 5',
       "'abc'[x]"                    => "The value 'x' cannot be converted to Numeric",
       "'abc'[1.0]"                  => "A String[] cannot use Float where Integer is expected",
       "'abc'[1,2,3]"                => "String supports [] with one or two arguments. Got 3",
       "Resource[0]"                 => 'First argument to Resource[] must be a resource type or a String. Got Integer',
       "Resource[a, 0]"              => 'Error creating type specialization of a Resource-Type, Cannot use Integer where a resource title String is expected',
       "File[0]"                     => 'Error creating type specialization of a File-Type, Cannot use Integer where a resource title String is expected',
       "String[a]"                   => "A Type's size constraint arguments must be a single Integer type, or 1-2 integers (or default). Got a String",
       "Pattern[0]"                  => 'Error creating type specialization of a Pattern-Type, Cannot use Integer where String or Regexp or Pattern-Type or Regexp-Type is expected',
       "Regexp[0]"                   => 'Error creating type specialization of a Regexp-Type, Cannot use Integer where String or Regexp is expected',
       "Regexp[a,b]"                 => 'A Regexp-Type[] accepts 1 argument. Got 2',
       "true[0]"                     => "Operator '[]' is not applicable to a Boolean",
       "1[0]"                        => "Operator '[]' is not applicable to an Integer",
       "3.14[0]"                     => "Operator '[]' is not applicable to a Float",
       "/.*/[0]"                     => "Operator '[]' is not applicable to a Regexp",
       "[1][a]"                      => "The value 'a' cannot be converted to Numeric",
       "[1][0.0]"                    => "An Array[] cannot use Float where Integer is expected",
       "[1]['0.0']"                  => "An Array[] cannot use Float where Integer is expected",
       "[1,2][1, 0.0]"               => "An Array[] cannot use Float where Integer is expected",
       "[1,2][1.0, -1]"              => "An Array[] cannot use Float where Integer is expected",
       "[1,2][1, -1.0]"              => "An Array[] cannot use Float where Integer is expected",
     }.each do |source, result|
       it "should parse and evaluate the expression '#{source}' to #{result}" do
         expect { parser.evaluate_string(scope, source, __FILE__)}.to raise_error(Regexp.new(Regexp.quote(result)))
       end
     end
 
     context "on catalog types" do
       it "[n] gets resource parameter [n]" do
         source = "notify { 'hello': message=>'yo'} Notify[hello][message]"
         parser.evaluate_string(scope, source, __FILE__).should == 'yo'
       end
 
       it "[n] gets class parameter [n]" do
         source = "class wonka($produces='chocolate'){ }
            include wonka
            Class[wonka][produces]"
 
         # This is more complicated since it needs to run like 3.x and do an import_ast
         adapted_parser = Puppet::Parser::E4ParserAdapter.new
         adapted_parser.file = __FILE__
         ast = adapted_parser.parse(source)
         Puppet.override({:global_scope => scope}, "test") do
           scope.known_resource_types.import_ast(ast, '')
           ast.code.safeevaluate(scope).should == 'chocolate'
         end
       end
 
       # Resource default and override expressions and resource parameter access with []
       {
         # Properties
         "notify { id: message=>explicit} Notify[id][message]"                   => "explicit",
         "Notify { message=>by_default} notify {foo:} Notify[foo][message]"      => "by_default",
         "notify {foo:} Notify[foo]{message =>by_override} Notify[foo][message]" => "by_override",
         # Parameters
         "notify { id: withpath=>explicit} Notify[id][withpath]"                 => "explicit",
         "Notify { withpath=>by_default } notify { foo: } Notify[foo][withpath]" => "by_default",
         "notify {foo:}
          Notify[foo]{withpath=>by_override}
          Notify[foo][withpath]"                                                 => "by_override",
         # Metaparameters
         "notify { foo: tag => evoe} Notify[foo][tag]"                           => "evoe",
         # Does not produce the defaults for tag parameter (title, type or names of scopes)
         "notify { foo: } Notify[foo][tag]"                                      => nil,
         # But a default may be specified on the type
         "Notify { tag=>by_default } notify { foo: } Notify[foo][tag]"           => "by_default",
         "Notify { tag=>by_default }
          notify { foo: }
          Notify[foo]{ tag=>by_override }
          Notify[foo][tag]"                                                      => "by_override",
       }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           parser.evaluate_string(scope, source, __FILE__).should == result
         end
       end
 
       # Virtual and realized resource default and overridden resource parameter access with []
       {
         # Properties
         "@notify { id: message=>explicit } Notify[id][message]"                 => "explicit",
         "@notify { id: message=>explicit }
          realize Notify[id]
          Notify[id][message]"                                                   => "explicit",
         "Notify { message=>by_default } @notify { id: } Notify[id][message]"    => "by_default",
         "Notify { message=>by_default }
          @notify { id: tag=>thisone }
          Notify <| tag == thisone |>;
          Notify[id][message]"                                                   => "by_default",
         "@notify { id: } Notify[id]{message=>by_override} Notify[id][message]"  => "by_override",
         # Parameters
         "@notify { id: withpath=>explicit } Notify[id][withpath]"               => "explicit",
         "Notify { withpath=>by_default }
          @notify { id: }
          Notify[id][withpath]"                                                  => "by_default",
         "@notify { id: }
          realize Notify[id]
          Notify[id]{withpath=>by_override}
          Notify[id][withpath]"                                                  => "by_override",
         # Metaparameters
         "@notify { id: tag=>explicit } Notify[id][tag]"                         => "explicit",
       }.each do |source, result|
         it "parses and evaluates virtual and realized resources in the expression '#{source}' to #{result}" do
           expect(parser.evaluate_string(scope, source, __FILE__)).to eq(result)
         end
       end
 
       # Exported resource attributes
       {
         "@@notify { id: message=>explicit } Notify[id][message]"                => "explicit",
         "@@notify { id: message=>explicit, tag=>thisone }
          Notify <<| tag == thisone |>>
          Notify[id][message]"                                                   => "explicit",
       }.each do |source, result|
         it "parses and evaluates exported resources in the expression '#{source}' to #{result}" do
           expect(parser.evaluate_string(scope, source, __FILE__)).to eq(result)
         end
       end
 
       # Resource default and override expressions and resource parameter access error conditions
       {
         "notify { xid: message=>explicit} Notify[id][message]"  => /Resource not found/,
         "notify { id: message=>explicit} Notify[id][mustard]"   => /does not have a parameter called 'mustard'/,
         # NOTE: these meta-esque parameters are not recognized as such
         "notify { id: message=>explicit} Notify[id][title]"   => /does not have a parameter called 'title'/,
         "notify { id: message=>explicit} Notify[id]['type']"   => /does not have a parameter called 'type'/,
         "notify { id: message=>explicit } Notify[id]{message=>override}" => /'message' is already set on Notify\[id\]/
       }.each do |source, result|
         it "should parse '#{source}' and raise error matching #{result}" do
           expect { parser.evaluate_string(scope, source, __FILE__)}.to raise_error(result)
         end
       end
 
       context 'with errors' do
         { "Class['fail-whale']" => /Illegal name/,
           "Class[0]"            => /An Integer cannot be used where a String is expected/,
           "Class[/.*/]"         => /A Regexp cannot be used where a String is expected/,
           "Class[4.1415]"       => /A Float cannot be used where a String is expected/,
           "Class[Integer]"      => /An Integer-Type cannot be used where a String is expected/,
           "Class[File['tmp']]"   => /A File\['tmp'\] Resource-Reference cannot be used where a String is expected/,
         }.each do | source, error_pattern|
           it "an error is flagged for '#{source}'" do
             expect { parser.evaluate_string(scope, source, __FILE__)}.to raise_error(error_pattern)
           end
         end
       end
     end
   # end [] operations
   end
 
   context "When the evaluator performs boolean operations" do
     {
       "true and true"   => true,
       "false and true"  => false,
       "true and false"  => false,
       "false and false" => false,
       "true or true"    => true,
       "false or true"   => true,
       "true or false"   => true,
       "false or false"  => false,
       "! true"          => false,
       "!! true"         => true,
       "!! false"        => false,
       "! 'x'"           => false,
       "! ''"            => false,
       "! undef"         => true,
       "! [a]"           => false,
       "! []"            => false,
       "! {a=>1}"        => false,
       "! {}"            => false,
       "true and false and '0xwtf' + 1"  => false,
       "false or true  or '0xwtf' + 1"  => true,
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           parser.evaluate_string(scope, source, __FILE__).should == result
         end
       end
 
     {
       "false || false || '0xwtf' + 1"   => :error,
     }.each do |source, result|
         it "should parse and raise error for '#{source}'" do
           expect { parser.evaluate_string(scope, source, __FILE__) }.to raise_error(Puppet::ParseError)
         end
       end
   end
 
   context "When evaluator performs operations on literal undef" do
     it "computes non existing hash lookup as undef" do
       parser.evaluate_string(scope, "{a => 1}[b] == undef", __FILE__).should == true
       parser.evaluate_string(scope, "undef == {a => 1}[b]", __FILE__).should == true
     end
   end
 
   context "When evaluator performs calls" do
 
     let(:populate) do
       parser.evaluate_string(scope, "$a = 10 $b = [1,2,3]")
     end
 
     {
       'sprintf( "x%iy", $a )'                 => "x10y",
       # unfolds
       'sprintf( *["x%iy", $a] )'              => "x10y",
       '"x%iy".sprintf( $a )'                  => "x10y",
       '$b.reduce |$memo,$x| { $memo + $x }'   => 6,
       'reduce($b) |$memo,$x| { $memo + $x }'  => 6,
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           populate
           parser.evaluate_string(scope, source, __FILE__).should == result
         end
       end
 
     {
       '"value is ${a*2} yo"'  => :error,
     }.each do |source, result|
         it "should parse and raise error for '#{source}'" do
           expect { parser.evaluate_string(scope, source, __FILE__) }.to raise_error(Puppet::ParseError)
         end
       end
 
     it "provides location information on error in unparenthesized call logic" do
     expect{parser.evaluate_string(scope, "include non_existing_class", __FILE__)}.to raise_error(Puppet::ParseError, /line 1\:1/)
     end
 
     it 'defaults can be given in a lambda and used only when arg is missing' do
       env_loader = @compiler.loaders.public_environment_loader
       fc = Puppet::Functions.create_function(:test) do
         dispatch :test do
           param 'Integer', 'count'
           required_block_param
         end
-        def test(count, block)
-          block.call(*[].fill(10, 0, count))
+        def test(count)
+          yield(*[].fill(10, 0, count))
         end
       end
       the_func = fc.new({}, env_loader)
       env_loader.add_entry(:function, 'test', the_func, __FILE__)
       expect(parser.evaluate_string(scope, "test(1) |$x, $y=20| { $x + $y}")).to eql(30)
       expect(parser.evaluate_string(scope, "test(2) |$x, $y=20| { $x + $y}")).to eql(20)
     end
 
     it 'a given undef does not select the default value' do
       env_loader = @compiler.loaders.public_environment_loader
       fc = Puppet::Functions.create_function(:test) do
         dispatch :test do
           param 'Any', 'lambda_arg'
           required_block_param
         end
-        def test(lambda_arg, block)
-          block.call(lambda_arg)
+        def test(lambda_arg)
+          yield(lambda_arg)
         end
       end
       the_func = fc.new({}, env_loader)
       env_loader.add_entry(:function, 'test', the_func, __FILE__)
 
       expect(parser.evaluate_string(scope, "test(undef) |$x=20| { $x == undef}")).to eql(true)
     end
 
     it 'a given undef is given as nil' do
       env_loader = @compiler.loaders.public_environment_loader
       fc = Puppet::Functions.create_function(:assert_no_undef) do
         dispatch :assert_no_undef do
           param 'Any', 'x'
         end
 
         def assert_no_undef(x)
           case x
           when Array
             return unless x.include?(:undef)
           when Hash
             return unless x.keys.include?(:undef) || x.values.include?(:undef)
           else
             return unless x == :undef
           end
           raise "contains :undef"
         end
       end
 
       the_func = fc.new({}, env_loader)
       env_loader.add_entry(:function, 'assert_no_undef', the_func, __FILE__)
 
       expect{parser.evaluate_string(scope, "assert_no_undef(undef)")}.to_not raise_error()
       expect{parser.evaluate_string(scope, "assert_no_undef([undef])")}.to_not raise_error()
       expect{parser.evaluate_string(scope, "assert_no_undef({undef => 1})")}.to_not raise_error()
       expect{parser.evaluate_string(scope, "assert_no_undef({1 => undef})")}.to_not raise_error()
     end
 
     context 'using the 3x function api' do
       it 'can call a 3x function' do
         Puppet::Parser::Functions.newfunction("bazinga", :type => :rvalue) { |args| args[0] }
         parser.evaluate_string(scope, "bazinga(42)", __FILE__).should == 42
       end
 
       it 'maps :undef to empty string' do
         Puppet::Parser::Functions.newfunction("bazinga", :type => :rvalue) { |args| args[0] }
         parser.evaluate_string(scope, "$a = {} bazinga($a[nope])", __FILE__).should == ''
         parser.evaluate_string(scope, "bazinga(undef)", __FILE__).should == ''
       end
 
       it 'does not map :undef to empty string in arrays' do
         Puppet::Parser::Functions.newfunction("bazinga", :type => :rvalue) { |args| args[0][0] }
         parser.evaluate_string(scope, "$a = {} $b = [$a[nope]] bazinga($b)", __FILE__).should == :undef
         parser.evaluate_string(scope, "bazinga([undef])", __FILE__).should == :undef
       end
 
       it 'does not map :undef to empty string in hashes' do
         Puppet::Parser::Functions.newfunction("bazinga", :type => :rvalue) { |args| args[0]['a'] }
         parser.evaluate_string(scope, "$a = {} $b = {a => $a[nope]} bazinga($b)", __FILE__).should == :undef
         parser.evaluate_string(scope, "bazinga({a => undef})", __FILE__).should == :undef
       end
     end
   end
 
   context "When evaluator performs string interpolation" do
     let(:populate) do
       parser.evaluate_string(scope, "$a = 10 $b = [1,2,3]")
     end
 
     {
       '"value is $a yo"'                      => "value is 10 yo",
       '"value is \$a yo"'                     => "value is $a yo",
       '"value is ${a} yo"'                    => "value is 10 yo",
       '"value is \${a} yo"'                   => "value is ${a} yo",
       '"value is ${$a} yo"'                   => "value is 10 yo",
       '"value is ${$a*2} yo"'                 => "value is 20 yo",
       '"value is ${sprintf("x%iy",$a)} yo"'   => "value is x10y yo",
       '"value is ${"x%iy".sprintf($a)} yo"'   => "value is x10y yo",
       '"value is ${[1,2,3]} yo"'              => "value is [1, 2, 3] yo",
       '"value is ${/.*/} yo"'                 => "value is /.*/ yo",
       '$x = undef "value is $x yo"'           => "value is  yo",
       '$x = default "value is $x yo"'         => "value is default yo",
       '$x = Array[Integer] "value is $x yo"'  => "value is Array[Integer] yo",
       '"value is ${Array[Integer]} yo"'       => "value is Array[Integer] yo",
     }.each do |source, result|
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           populate
           parser.evaluate_string(scope, source, __FILE__).should == result
         end
       end
 
     it "should parse and evaluate an interpolation of a hash" do
       source = '"value is ${{a=>1,b=>2}} yo"'
       # This test requires testing against two options because a hash to string
       # produces a result that is unordered
       hashstr = {'a' => 1, 'b' => 2}.to_s
       alt_results = ["value is {a => 1, b => 2} yo", "value is {b => 2, a => 1} yo" ]
       populate
       parse_result = parser.evaluate_string(scope, source, __FILE__)
       alt_results.include?(parse_result).should == true
     end
 
     it 'should accept a variable with leading underscore when used directly' do
       source = '$_x = 10; "$_x"'
       expect(parser.evaluate_string(scope, source, __FILE__)).to eql('10')
     end
 
     it 'should accept a variable with leading underscore when used as an expression' do
       source = '$_x = 10; "${_x}"'
       expect(parser.evaluate_string(scope, source, __FILE__)).to eql('10')
     end
 
     {
       '"value is ${a*2} yo"'  => :error,
     }.each do |source, result|
         it "should parse and raise error for '#{source}'" do
           expect { parser.evaluate_string(scope, source, __FILE__) }.to raise_error(Puppet::ParseError)
         end
       end
   end
 
   context "When evaluating variables" do
     context "that are non existing an error is raised for" do
       it "unqualified variable" do
         expect { parser.evaluate_string(scope, "$quantum_gravity", __FILE__) }.to raise_error(/Unknown variable/)
       end
 
       it "qualified variable" do
         expect { parser.evaluate_string(scope, "$quantum_gravity::graviton", __FILE__) }.to raise_error(/Unknown variable/)
       end
     end
 
     it "a lex error should be raised for '$foo::::bar'" do
       expect { parser.evaluate_string(scope, "$foo::::bar") }.to raise_error(Puppet::LexError, /Illegal fully qualified name at line 1:7/)
     end
 
     { '$a = $0'   => nil,
       '$a = $1'   => nil,
     }.each do |source, value|
       it "it is ok to reference numeric unassigned variables '#{source}'" do
         parser.evaluate_string(scope, source, __FILE__).should == value
       end
     end
 
     { '$00 = 0'   => /must be a decimal value/,
       '$0xf = 0'  => /must be a decimal value/,
       '$0777 = 0' => /must be a decimal value/,
       '$123a = 0' => /must be a decimal value/,
     }.each do |source, error_pattern|
       it "should raise an error for '#{source}'" do
         expect { parser.evaluate_string(scope, source, __FILE__) }.to raise_error(error_pattern)
       end
     end
 
     context "an initial underscore in the last segment of a var name is allowed" do
       { '$_a  = 1'   => 1,
         '$__a = 1'   => 1,
       }.each do |source, value|
         it "as in this example '#{source}'" do
           parser.evaluate_string(scope, source, __FILE__).should == value
         end
       end
     end
   end
 
   context "When evaluating relationships" do
     it 'should form a relation with File[a] -> File[b]' do
       source = "File[a] -> File[b]"
       parser.evaluate_string(scope, source, __FILE__)
       scope.compiler.should have_relationship(['File', 'a', '->', 'File', 'b'])
     end
 
     it 'should form a relation with resource -> resource' do
       source = "notify{a:} -> notify{b:}"
       parser.evaluate_string(scope, source, __FILE__)
       scope.compiler.should have_relationship(['Notify', 'a', '->', 'Notify', 'b'])
     end
 
     it 'should form a relation with [File[a], File[b]] -> [File[x], File[y]]' do
       source = "[File[a], File[b]] -> [File[x], File[y]]"
       parser.evaluate_string(scope, source, __FILE__)
       scope.compiler.should have_relationship(['File', 'a', '->', 'File', 'x'])
       scope.compiler.should have_relationship(['File', 'b', '->', 'File', 'x'])
       scope.compiler.should have_relationship(['File', 'a', '->', 'File', 'y'])
       scope.compiler.should have_relationship(['File', 'b', '->', 'File', 'y'])
     end
 
     it 'should tolerate (eliminate) duplicates in operands' do
       source = "[File[a], File[a]] -> File[x]"
       parser.evaluate_string(scope, source, __FILE__)
       scope.compiler.should have_relationship(['File', 'a', '->', 'File', 'x'])
       scope.compiler.relationships.size.should == 1
     end
 
     it 'should form a relation with <-' do
       source = "File[a] <- File[b]"
       parser.evaluate_string(scope, source, __FILE__)
       scope.compiler.should have_relationship(['File', 'b', '->', 'File', 'a'])
     end
 
     it 'should form a relation with <-' do
       source = "File[a] <~ File[b]"
       parser.evaluate_string(scope, source, __FILE__)
       scope.compiler.should have_relationship(['File', 'b', '~>', 'File', 'a'])
     end
   end
 
   context "When evaluating heredoc" do
     it "evaluates plain heredoc" do
       src = "@(END)\nThis is\nheredoc text\nEND\n"
       parser.evaluate_string(scope, src).should == "This is\nheredoc text\n"
     end
 
     it "parses heredoc with margin" do
       src = [
       "@(END)",
       "   This is",
       "   heredoc text",
       "   | END",
       ""
       ].join("\n")
       parser.evaluate_string(scope, src).should == "This is\nheredoc text\n"
     end
 
     it "parses heredoc with margin and right newline trim" do
       src = [
       "@(END)",
       "   This is",
       "   heredoc text",
       "   |- END",
       ""
       ].join("\n")
       parser.evaluate_string(scope, src).should == "This is\nheredoc text"
     end
 
     it "parses escape specification" do
       src = <<-CODE
       @(END/t)
       Tex\\tt\\n
       |- END
       CODE
       parser.evaluate_string(scope, src).should == "Tex\tt\\n"
     end
 
     it "parses syntax checked specification" do
       src = <<-CODE
       @(END:json)
       ["foo", "bar"]
       |- END
       CODE
       parser.evaluate_string(scope, src).should == '["foo", "bar"]'
     end
 
     it "parses syntax checked specification with error and reports it" do
       src = <<-CODE
       @(END:json)
       ['foo', "bar"]
       |- END
       CODE
       expect { parser.evaluate_string(scope, src)}.to raise_error(/Cannot parse invalid JSON string/)
     end
 
     it "parses interpolated heredoc expression" do
       src = <<-CODE
       $name = 'Fjodor'
       @("END")
       Hello $name
       |- END
       CODE
       parser.evaluate_string(scope, src).should == "Hello Fjodor"
     end
 
   end
   context "Handles Deprecations and Discontinuations" do
     it 'of import statements' do
       source = "\nimport foo"
       # Error references position 5 at the opening '{'
       # Set file to nil to make it easier to match with line number (no file name in output)
       expect { parser.evaluate_string(scope, source) }.to raise_error(/'import' has been discontinued.*line 2:1/)
     end
   end
 
   context "Detailed Error messages are reported" do
     it 'for illegal type references' do
       source = '1+1 { "title": }'
       # Error references position 5 at the opening '{'
       # Set file to nil to make it easier to match with line number (no file name in output)
       expect { parser.evaluate_string(scope, source) }.to raise_error(
         /Illegal Resource Type expression, expected result to be a type name, or untitled Resource.*line 1:2/)
     end
 
     it 'for non r-value producing <| |>' do
       expect { parser.parse_string("$a = File <| |>", nil) }.to raise_error(/A Virtual Query does not produce a value at line 1:6/)
     end
 
     it 'for non r-value producing <<| |>>' do
       expect { parser.parse_string("$a = File <<| |>>", nil) }.to raise_error(/An Exported Query does not produce a value at line 1:6/)
     end
 
     it 'for non r-value producing define' do
       Puppet.expects(:err).with("Invalid use of expression. A 'define' expression does not produce a value at line 1:6")
       Puppet.expects(:err).with("Classes, definitions, and nodes may only appear at toplevel or inside other classes at line 1:6")
       expect { parser.parse_string("$a = define foo { }", nil) }.to raise_error(/2 errors/)
     end
 
     it 'for non r-value producing class' do
       Puppet.expects(:err).with("Invalid use of expression. A Host Class Definition does not produce a value at line 1:6")
       Puppet.expects(:err).with("Classes, definitions, and nodes may only appear at toplevel or inside other classes at line 1:6")
       expect { parser.parse_string("$a = class foo { }", nil) }.to raise_error(/2 errors/)
     end
 
     it 'for unclosed quote with indication of start position of string' do
       source = <<-SOURCE.gsub(/^ {6}/,'')
       $a = "xx
       yyy
       SOURCE
       # first char after opening " reported as being in error.
       expect { parser.parse_string(source) }.to raise_error(/Unclosed quote after '"' followed by 'xx\\nyy\.\.\.' at line 1:7/)
     end
 
     it 'for multiple errors with a summary exception' do
       Puppet.expects(:err).with("Invalid use of expression. A Node Definition does not produce a value at line 1:6")
       Puppet.expects(:err).with("Classes, definitions, and nodes may only appear at toplevel or inside other classes at line 1:6")
       expect { parser.parse_string("$a = node x { }",nil) }.to raise_error(/2 errors/)
     end
 
     it 'for a bad hostname' do
       expect {
         parser.parse_string("node 'macbook+owned+by+name' { }", nil)
       }.to raise_error(/The hostname 'macbook\+owned\+by\+name' contains illegal characters.*at line 1:6/)
     end
 
     it 'for a hostname with interpolation' do
       source = <<-SOURCE.gsub(/^ {6}/,'')
       $name = 'fred'
       node "macbook-owned-by$name" { }
       SOURCE
       expect {
         parser.parse_string(source, nil)
       }.to raise_error(/An interpolated expression is not allowed in a hostname of a node at line 2:23/)
     end
 
   end
 
   context 'does not leak variables' do
     it 'local variables are gone when lambda ends' do
       source = <<-SOURCE
       [1,2,3].each |$x| { $y = $x}
       $a = $y
       SOURCE
       expect do
         parser.evaluate_string(scope, source)
       end.to raise_error(/Unknown variable: 'y'/)
     end
 
     it 'lambda parameters are gone when lambda ends' do
       source = <<-SOURCE
       [1,2,3].each |$x| { $y = $x}
       $a = $x
       SOURCE
       expect do
         parser.evaluate_string(scope, source)
       end.to raise_error(/Unknown variable: 'x'/)
     end
 
     it 'does not leak match variables' do
       source = <<-SOURCE
       if 'xyz' =~ /(x)(y)(z)/ { notice $2 }
       case 'abc' {
         /(a)(b)(c)/ : { $x = $2 }
       }
       "-$x-$2-"
       SOURCE
       expect(parser.evaluate_string(scope, source)).to eq('-b--')
     end
   end
 
   matcher :have_relationship do |expected|
     calc = Puppet::Pops::Types::TypeCalculator.new
 
     match do |compiler|
       op_name = {'->' => :relationship, '~>' => :subscription}
       compiler.relationships.any? do | relation |
         relation.source.type == expected[0] &&
         relation.source.title == expected[1] &&
         relation.type == op_name[expected[2]] &&
         relation.target.type == expected[3] &&
         relation.target.title == expected[4]
       end
     end
 
     failure_message_for_should do |actual|
       "Relationship #{expected[0]}[#{expected[1]}] #{expected[2]} #{expected[3]}[#{expected[4]}] but was unknown to compiler"
     end
   end
 
 end