diff --git a/lib/hiera/puppet_function.rb b/lib/hiera/puppet_function.rb
index b167c15b1..a42821c2d 100644
--- a/lib/hiera/puppet_function.rb
+++ b/lib/hiera/puppet_function.rb
@@ -1,72 +1,71 @@
 require 'hiera_puppet'
 
 # Provides the base class for the puppet functions hiera, hiera_array, hiera_hash, and hiera_include.
 # The actual function definitions will call init_dispatch and override the merge_type and post_lookup methods.
 #
 # @see hiera_array.rb, hiera_include.rb under lib/puppet/functions for sample usage
 #
 class Hiera::PuppetFunction < Puppet::Functions::InternalFunction
   def self.init_dispatch
     dispatch :hiera_splat do
       scope_param
       param 'Tuple[String, Any, Any, 1, 3]', :args
     end
 
     dispatch :hiera do
       scope_param
       param 'String',:key
-      param 'Any',   :default
-      param 'Any',   :override
-      arg_count(1,3)
+      optional_param 'Any',   :default
+      optional_param 'Any',   :override
     end
 
     dispatch :hiera_block1 do
       scope_param
-      param 'String',        :key
-      required_block_param 'Callable[1,1]', :default_block
+      param 'String',              :key
+      block_param 'Callable[1,1]', :default_block
     end
 
     dispatch :hiera_block2 do
       scope_param
-      param 'String',                       :key
-      param 'Any',                          :override
-      required_block_param 'Callable[1,1]', :default_block
+      param 'String',              :key
+      param 'Any',                 :override
+      block_param 'Callable[1,1]', :default_block
     end
   end
 
   def hiera_splat(scope, args)
     hiera(scope, *args)
   end
 
   def hiera(scope, key, default = nil, override = nil)
     post_lookup(key, lookup(scope, key, default, override))
   end
 
   def hiera_block1(scope, key, &default_block)
     common(scope, key, nil, default_block)
   end
 
   def hiera_block2(scope, key, override, &default_block)
     common(scope, key, override, default_block)
   end
 
   def common(scope, key, override, default_block)
     undefined = (@@undefined_value ||= Object.new)
     result = lookup(scope, key, undefined, override)
     post_lookup(key, result.equal?(undefined) ? default_block.call(key) : result)
   end
 
   private :common
 
   def lookup(scope, key, default, override)
     HieraPuppet.lookup(key, default,scope, override, merge_type)
   end
 
   def merge_type
     :priority
   end
 
   def post_lookup(key, result)
     result
   end
 end
diff --git a/lib/puppet/functions.rb b/lib/puppet/functions.rb
index f0029670c..1a888d743 100644
--- a/lib/puppet/functions.rb
+++ b/lib/puppet/functions.rb
@@ -1,571 +1,608 @@
 # @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'
+#       param 'Numeric', :a
+#       param 'Numeric', :b
 #     end
 #
 #     dispatch :string_min do
-#       param 'String', 'a'
-#       param 'String', 'b'
+#       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.
+# The following methods can be used to define a parameter
 #
-# 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 `*`).
+#  - _param_ - the argument must be given in the call.
+#  - _optional_param_ - the argument may be missing in the call. May not be followed by a required parameter
+#  - _repeated_param_ - the type specifies a repeating type that occurs 0 to "infinite" number of times. It may only appear last or just before a block parameter.
+#  - _block_param_ - a block must be given in the call. May only appear last.
+#  - _optional_block_param_ - a block may be given in the call. May only appear last.
 #
-# @example Varargs
+# The method name _required_param_ is an alias for _param_ and _required_block_param_ is an alias for _block_param_
+#
+# A parameter definition takes 2 arguments:
+#  - _type_ A string that must conform to a type in the puppet language
+#  - _name_ A symbol denoting the parameter name
+#
+# Both arguments are optional when defining a block parameter. The _type_ defaults to "Callable"
+# and the _name_ to :block.
+#
+# Note that the dispatch definition is used to match arguments given in a call to the function with the defined
+# parameters. It then dispatches the call to the implementation method simply passing the given arguments on to
+# that method without any further processing and it is the responsibility of that method's implementor to ensure
+# that it can handle those arguments.
+#
+# @example Variable number of arguments
 #   Puppet::Functions.create_function('foo') do
 #     dispatch :foo do
-#       param 'Numeric', 'first'
-#       param 'Numeric', 'values'
-#       last_captures_rest
+#       param 'Numeric', :first
+#       repeated_param 'Numeric', :values
 #     end
 #
 #     def foo(first, *values)
 #       # do something
 #     end
 #   end
 #
+# There is no requirement for direct mapping between parameter definitions and the parameters in the
+# receiving implementation method so the following example is also legal. Here the dispatch will ensure
+# that `*values` in the receiver will be an array with at least one entry of type String and that any
+# remaining entries are of type Numeric:
+#
+# @example Inexact mapping or parameters
+#   Puppet::Functions.create_function('foo') do
+#     dispatch :foo do
+#       param 'String', :first
+#       repeated_param 'Numeric', :values
+#     end
+#
+#     def foo(*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
+    # Defines a required 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.
+    # @param name [Symbol] The name of the parameter. This is primarily used
+    #   for error message output and does not have to match an implementation
+    #   method parameter.
     # @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
+      internal_param(type, name)
+      raise ArgumentError, 'A required parameter cannot be added after an optional parameter' if @min != @max
+      @min += 1
+      @max += 1
+    end
+    alias required_param param
+
+    # Defines an optional positional parameter with _type_ and _name_.
+    # May not be followed by a required parameter.
+    #
+    # @param type [String] The type specification for the parameter.
+    # @param name [Symbol] The name of the parameter. This is primarily used
+    #   for error message output and does not have to match an implementation
+    #   method parameter.
+    # @return [Void]
+    #
+    # @api public
+    def optional_param(type, name)
+      internal_param(type, name)
+      @max += 1
+    end
+
+    # Defines a repeated positional parameter with _type_ and _name_ that may occur 0 to "infinite" number of times.
+    # It may only appear last or just before a block parameter.
+    #
+    # @param type [String] The type specification for the parameter.
+    # @param name [Symbol] The name of the parameter. This is primarily used
+    #   for error message output and does not have to match an implementation
+    #   method parameter.
+    # @return [Void]
+    #
+    # @api public
+    def repeated_param(type, name)
+      internal_param(type, name)
+      @max = :default
     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)
+    def 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
       else
         raise ArgumentError, 'Attempt to redefine block'
       end
     end
+    alias required_block_param block_param
 
     # 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 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
-      if max_occurs == :default
-        @last_captures = true
+    private
+
+    # @api private
+    def internal_param(type, name)
+      raise ArgumentError, 'Parameters cannot be added after a block parameter' unless @block_type.nil?
+      raise ArgumentError, 'Parameters cannot be added after a repeated parameter' if @max == :default
+      if type.is_a?(String)
+        @types << type
+        @names << name
+        # mark what should be picked for this position when dispatching
+        @weaving << @names.size()-1
       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
+        raise ArgumentError, "Parameter 'type' must be a String reference to a Puppet Data Type. Got #{type.class}"
       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
+      @min = 0
+      @max = 0
       @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)
+      @dispatcher.add_dispatch(callable_t, meth_name, @names, @block_name, @injections, @weaving, @max == :default)
     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?)
+      if from != to
+        # :optional and/or :repeated parameters are present.
         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/each.rb b/lib/puppet/functions/each.rb
index a9c9caf7b..c52aeaafb 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
+    block_param 'Callable[2,2]', :block
   end
 
   dispatch :foreach_Hash_1 do
     param 'Hash[Any, Any]', :hash
-    required_block_param 'Callable[1,1]', :block
+    block_param 'Callable[1,1]', :block
   end
 
   dispatch :foreach_Enumerable_2 do
     param 'Any', :enumerable
-    required_block_param 'Callable[2,2]', :block
+    block_param 'Callable[2,2]', :block
   end
 
   dispatch :foreach_Enumerable_1 do
     param 'Any', :enumerable
-    required_block_param 'Callable[1,1]', :block
+    block_param 'Callable[1,1]', :block
   end
 
   def foreach_Hash_1(hash)
     enumerator = hash.each_pair
     hash.size.times do
       yield(enumerator.next)
     end
     # produces the receiver
     hash
   end
 
   def foreach_Hash_2(hash)
     enumerator = hash.each_pair
     hash.size.times do
       yield(*enumerator.next)
     end
     # produces the receiver
     hash
   end
 
   def foreach_Enumerable_1(enumerable)
     enum = asserted_enumerable(enumerable)
       begin
         loop { yield(enum.next) }
       rescue StopIteration
       end
     # produces the receiver
     enumerable
   end
 
   def foreach_Enumerable_2(enumerable)
     enum = asserted_enumerable(enumerable)
     index = 0
     begin
       loop do
         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/epp.rb b/lib/puppet/functions/epp.rb
index baa0c1bed..2477a1e2e 100644
--- a/lib/puppet/functions/epp.rb
+++ b/lib/puppet/functions/epp.rb
@@ -1,54 +1,53 @@
 # Evaluates an Embedded Puppet Template (EPP) file and returns the rendered text result as a String.
 #
 # The first argument to this function should be a `<MODULE NAME>/<TEMPLATE FILE>`
 # reference, which will load `<TEMPLATE FILE>` from a module's `templates`
 # directory. (For example, the reference `apache/vhost.conf.epp` will load the
 # file `<MODULES DIRECTORY>/apache/templates/vhost.conf.epp`.)
 #
 # The second argument is optional; if present, it should be a hash containing parameters for the
 # template. (See below.)
 #
 # EPP supports the following tags:
 #
 # * `<%= puppet expression %>` - This tag renders the value of the expression it contains.
 # * `<% puppet expression(s) %>` - This tag will execute the expression(s) it contains, but renders nothing.
 # * `<%# comment %>` - The tag and its content renders nothing.
 # * `<%%` or `%%>` - Renders a literal `<%` or `%>` respectively.
 # * `<%-` - Same as `<%` but suppresses any leading whitespace.
 # * `-%>` - Same as `%>` but suppresses any trailing whitespace on the same line (including line break).
 # * `<%- |parameters| -%>` - When placed as the first tag declares the template's parameters.
 #
 # File based EPP supports the following visibilities of variables in scope:
 #
 # * Global scope (i.e. top + node scopes) - global scope is always visible
 # * Global + all given arguments - if the EPP template does not declare parameters, and arguments are given
 # * Global + declared parameters - if the EPP declares parameters, given argument names must match
 #
 # EPP supports parameters by placing an optional parameter list as the very first element in the EPP. As an example,
 # `<%- |$x, $y, $z = 'unicorn'| -%>` when placed first in the EPP text declares that the parameters `x` and `y` must be
 # given as template arguments when calling `inline_epp`, and that `z` if not given as a template argument
 # defaults to `'unicorn'`. Template parameters are available as variables, e.g.arguments `$x`, `$y` and `$z` in the example.
 # Note that `<%-` must be used or any leading whitespace will be interpreted as text
 #
 # Arguments are passed to the template by calling `epp` with a Hash as the last argument, where parameters
 # are bound to values, e.g. `epp('...', {'x'=>10, 'y'=>20})`. Excess arguments may be given
 # (i.e. undeclared parameters) only if the EPP templates does not declare any parameters at all.
 # Template parameters shadow variables in outer scopes. File based epp does never have access to variables in the
 # scope where the `epp` function is called from.
 #
 # @see function inline_epp for examples of EPP
 # @since 3.5
 # @note Requires Future Parser
 Puppet::Functions.create_function(:epp, Puppet::Functions::InternalFunction) do
 
   dispatch :epp do
-    scope_param()
-    param 'String', 'path'
-    param 'Hash[Pattern[/^\w+$/], Any]', 'parameters'
-    arg_count(1, 2)
+    scope_param
+    param 'String', :path
+    optional_param 'Hash[Pattern[/^\w+$/], Any]', :parameters
   end
 
   def epp(scope, path, parameters = nil)
     Puppet::Pops::Evaluator::EppEvaluator.epp(scope, path, scope.compiler.environment, parameters)
   end
 end
\ No newline at end of file
diff --git a/lib/puppet/functions/filter.rb b/lib/puppet/functions/filter.rb
index 0edcfbbad..0552943d9 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
+    block_param 'Callable[2,2]', :block
   end
 
   dispatch :filter_Hash_1 do
     param 'Hash[Any, Any]', :hash
-    required_block_param 'Callable[1,1]', :block
+    block_param 'Callable[1,1]', :block
   end
 
   dispatch :filter_Enumerable_2 do
     param 'Any', :enumerable
-    required_block_param 'Callable[2,2]', :block
+    block_param 'Callable[2,2]', :block
   end
 
   dispatch :filter_Enumerable_1 do
     param 'Any', :enumerable
-    required_block_param 'Callable[1,1]', :block
+    block_param 'Callable[1,1]', :block
   end
 
   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)
     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)
     result = []
     index = 0
     enum = asserted_enumerable(enumerable)
     begin
       loop do
         it = enum.next
         if yield(it) == true
           result << it
         end
       end
     rescue StopIteration
     end
     result
   end
 
   def filter_Enumerable_2(enumerable)
     result = []
     index = 0
     enum = asserted_enumerable(enumerable)
     begin
       loop do
         it = enum.next
         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/inline_epp.rb b/lib/puppet/functions/inline_epp.rb
index 31a966334..06c7e3838 100644
--- a/lib/puppet/functions/inline_epp.rb
+++ b/lib/puppet/functions/inline_epp.rb
@@ -1,88 +1,87 @@
 # Evaluates an Embedded Puppet Template (EPP) string and returns the rendered text result as a String.
 #
 # EPP support the following tags:
 #
 # * `<%= puppet expression %>` - This tag renders the value of the expression it contains.
 # * `<% puppet expression(s) %>` - This tag will execute the expression(s) it contains, but renders nothing.
 # * `<%# comment %>` - The tag and its content renders nothing.
 # * `<%%` or `%%>` - Renders a literal `<%` or `%>` respectively.
 # * `<%-` - Same as `<%` but suppresses any leading whitespace.
 # * `-%>` - Same as `%>` but suppresses any trailing whitespace on the same line (including line break).
 # * `<%- |parameters| -%>` - When placed as the first tag declares the template's parameters.
 #
 # Inline EPP supports the following visibilities of variables in scope which depends on how EPP parameters
 # are used - see further below:
 #
 # * Global scope (i.e. top + node scopes) - global scope is always visible
 # * Global + Enclosing scope - if the EPP template does not declare parameters, and no arguments are given
 # * Global + all given arguments - if the EPP template does not declare parameters, and arguments are given
 # * Global + declared parameters - if the EPP declares parameters, given argument names must match
 #
 # EPP supports parameters by placing an optional parameter list as the very first element in the EPP. As an example,
 # `<%- |$x, $y, $z='unicorn'| -%>` when placed first in the EPP text declares that the parameters `x` and `y` must be
 # given as template arguments when calling `inline_epp`, and that `z` if not given as a template argument
 # defaults to `'unicorn'`. Template parameters are available as variables, e.g.arguments `$x`, `$y` and `$z` in the example.
 # Note that `<%-` must be used or any leading whitespace will be interpreted as text
 #
 # Arguments are passed to the template by calling `inline_epp` with a Hash as the last argument, where parameters
 # are bound to values, e.g. `inline_epp('...', {'x'=>10, 'y'=>20})`. Excess arguments may be given
 # (i.e. undeclared parameters) only if the EPP templates does not declare any parameters at all.
 # Template parameters shadow variables in outer scopes.
 #
 # Note: An inline template is best stated using a single-quoted string, or a heredoc since a double-quoted string
 # is subject to expression interpolation before the string is parsed as an EPP template. Here are examples
 # (using heredoc to define the EPP text):
 #
 # @example Various Examples using `inline_epp`
 #
 #     # produces 'Hello local variable world!'
 #     $x ='local variable'
 #     inline_epptemplate(@(END:epp))
 #     <%- |$x| -%>
 #     Hello <%= $x %> world!
 #     END
 # 
 #     # produces 'Hello given argument world!'
 #     $x ='local variable world'
 #     inline_epptemplate(@(END:epp), { x =>'given argument'})
 #     <%- |$x| -%>
 #     Hello <%= $x %> world!
 #     END
 #
 #     # produces 'Hello given argument world!'
 #     $x ='local variable world'
 #     inline_epptemplate(@(END:epp), { x =>'given argument'})
 #     <%- |$x| -%>
 #     Hello <%= $x %>!
 #     END
 #
 #     # results in error, missing value for y
 #     $x ='local variable world'
 #     inline_epptemplate(@(END:epp), { x =>'given argument'})
 #     <%- |$x, $y| -%>
 #     Hello <%= $x %>!
 #     END
 #
 #     # Produces 'Hello given argument planet'
 #     $x ='local variable world'
 #     inline_epptemplate(@(END:epp), { x =>'given argument'})
 #     <%- |$x, $y=planet| -%>
 #     Hello <%= $x %> <%= $y %>!
 #     END
 #
 # @since 3.5
 # @note Requires Future Parser
 #
 Puppet::Functions.create_function(:inline_epp, Puppet::Functions::InternalFunction) do
 
   dispatch :inline_epp do
     scope_param()
-    param 'String', 'template'
-    param 'Hash[Pattern[/^\w+$/], Any]', 'parameters'
-    arg_count(1, 2)
+    param 'String', :template
+    optional_param 'Hash[Pattern[/^\w+$/], Any]', :parameters
   end
 
   def inline_epp(scope, template, parameters = nil)
     Puppet::Pops::Evaluator::EppEvaluator.inline_epp(scope, template, parameters)
   end
 end
diff --git a/lib/puppet/functions/map.rb b/lib/puppet/functions/map.rb
index 41e79a382..857c1bfca 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
+    block_param 'Callable[2,2]', :block
   end
 
   dispatch :map_Hash_1 do
     param 'Hash[Any, Any]', :hash
-    required_block_param 'Callable[1,1]', :block
+    block_param 'Callable[1,1]', :block
   end
 
   dispatch :map_Enumerable_2 do
     param 'Any', :enumerable
-    required_block_param 'Callable[2,2]', :block
+    block_param 'Callable[2,2]', :block
   end
 
   dispatch :map_Enumerable_1 do
     param 'Any', :enumerable
-    required_block_param 'Callable[1,1]', :block
+    block_param 'Callable[1,1]', :block
   end
 
   def map_Hash_1(hash)
     hash.map {|x, y| yield([x, y]) }
   end
 
   def map_Hash_2(hash)
       hash.map {|x, y| yield(x, y) }
   end
 
   def map_Enumerable_1(enumerable)
     result = []
     index = 0
     enum = asserted_enumerable(enumerable)
     begin
       loop { result << yield(enum.next) }
     rescue StopIteration
     end
     result
   end
 
   def map_Enumerable_2(enumerable)
     result = []
     index = 0
     enum = asserted_enumerable(enumerable)
     begin
       loop do
         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 ef3fa30ac..48d0c3d7c 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
+    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
+    block_param 'Callable[2,2]', :block
   end
 
   def reduce_without_memo(enumerable)
     enum = asserted_enumerable(enumerable)
     enum.reduce {|memo, x| yield(memo, x) }
   end
 
   def reduce_with_memo(enumerable, given_memo)
     enum = asserted_enumerable(enumerable)
     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/with.rb b/lib/puppet/functions/with.rb
index cde4056d8..1c295f2ef 100644
--- a/lib/puppet/functions/with.rb
+++ b/lib/puppet/functions/with.rb
@@ -1,23 +1,22 @@
 # 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
+    repeated_param 'Any', :arg
+    block_param
   end
 
   def with(*args)
     yield(*args)
   end
 end
diff --git a/spec/unit/functions4_spec.rb b/spec/unit/functions4_spec.rb
index cc95f0d79..4a2c0e062 100644
--- a/spec/unit/functions4_spec.rb
+++ b/spec/unit/functions4_spec.rb
@@ -1,677 +1,733 @@
 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 use inexact argument mapping' do
+      f = create_function_with_inexact_dispatch
+      func = f.new(:closure_scope, :loader)
+      expect(func.call({}, 3,4,5)).to eql([Fixnum, Fixnum, Fixnum])
+      expect(func.call({}, 'Apple', 'Banana')).to eql([String, String])
+    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 'a function can not be created with parameters declared after a repeated parameter' do
+      expect { create_function_with_param_after_repeated }.to raise_error(ArgumentError, 'Parameters cannot be added after a repeated parameter')
+    end
+
+    it 'a function can not be created with required parameters declared after optional ones' do
+      expect { create_function_with_rq_after_opt }.to raise_error(ArgumentError, 'A required parameter cannot be added after an optional parameter')
+    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
         the_function = create_function_with_required_block_all_defaults().new(:closure_scope, :loader)
         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
         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
         the_function = create_function_with_optional_block_all_defaults().new(:closure_scope, :loader)
         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
         the_function = create_function_with_optional_block_all_defaults().new(:closure_scope, :loader)
         expect(the_function.call({}, 2)).to be_nil
       end
 
       it 'such that, a scope can be injected and a block can be used' do
         the_function = create_function_with_scope_required_block_all_defaults().new(:closure_scope, :loader)
         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)
             # call the block with 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
+        param 'Numeric', :x
+        param 'Numeric', :y
+        optional_param 'Numeric', :a
+        optional_param 'Numeric', :b
+        repeated_param 'Numeric', :c
       end
       def min(x,y,a=1, b=1, *c)
         x <= y ? x : y
       end
     end
   end
 
+  def create_function_with_inexact_dispatch
+    f = Puppet::Functions.create_function('t1') do
+      dispatch :t1 do
+        param 'Numeric', :x
+        param 'Numeric', :y
+        repeated_param 'Numeric', :z
+      end
+      dispatch :t1 do
+        param 'String', :x
+        param 'String', :y
+        repeated_param 'String', :z
+      end
+      def t1(first, *x)
+        [first.class, *x.map {|e|e.class}]
+      end
+    end
+  end
+
+  def create_function_with_rq_after_opt
+    f = Puppet::Functions.create_function('t1') do
+      dispatch :t1 do
+        optional_param 'Numeric', :x
+        param 'Numeric', :y
+      end
+      def t1(*x)
+        x
+      end
+    end
+  end
+
+  def create_function_with_param_after_repeated
+    f = Puppet::Functions.create_function('t1') do
+      dispatch :t1 do
+        repeated_param 'Numeric', :x
+        param 'Numeric', :y
+      end
+      def t1(*x)
+        x
+      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
+        block_param
       end
       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)
         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)
         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)
         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)
         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)
         yield(5,x) if block_given?
       end
     end
   end
 
 end