diff --git a/lib/puppet/functions.rb b/lib/puppet/functions.rb
index 127664bb4..b31583784 100644
--- a/lib/puppet/functions.rb
+++ b/lib/puppet/functions.rb
@@ -1,540 +1,542 @@
-# @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] == Float::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)
     result = {:req => 0, :opt => 0, :rest => 0 }
     # count per parameter kind, and get array of names
     names = method.parameters.map { |p| result[p[0]] += 1 ; p[1].to_s }
     from = result[:req]
     to = result[:rest] > 0 ? :default : from + result[:opt]
     [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
+    # @param name [Symbol] 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)
-      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 type.is_a?(String)
         raise ArgumentError, "Type signature argument must be a String reference to a Puppet Data Type. Got #{type.class}"
       end
+
+      unless name.is_a?(Symbol)
+        raise ArgumentError, "Parameter name argument must be a Symbol. Got #{type.class}"
+      end
+
+      @types << type
+      @names << name
+      # mark what should be picked for this position when dispatching
+      @weaving << @names.size()-1
     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'
+        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}"
+      unless name.is_a?(Symbol)
+        raise ArgumentError, "Expected block_param name to be a Symbol, got #{name.class}"
       end
 
       if @block_type.nil?
         @block_type = type
         @block_name = name
       else
         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 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}'"
       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
   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..6998f5137 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'
+    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'
+    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)
     unless Puppet::Pops::Types::TypeCalculator.instance?(type,value)
       inferred_type = Puppet::Pops::Types::TypeCalculator.infer(value)
       if block
         # Give the inferred type to allow richer comparisson in the given block (if generalized
         # information is lost).
         #
         value = block.call(nil, 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)
     t = Puppet::Pops::Types::TypeParser.new.parse(type_string)
     assert_type(t, value)
   end
 end
diff --git a/lib/puppet/functions/epp.rb b/lib/puppet/functions/epp.rb
index 35ff0286c..51aab6d2e 100644
--- a/lib/puppet/functions/epp.rb
+++ b/lib/puppet/functions/epp.rb
@@ -1,54 +1,54 @@
 # 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 4.0.0
 #
 Puppet::Functions.create_function(:epp, Puppet::Functions::InternalFunction) do
 
   dispatch :epp do
     scope_param()
-    param 'String', 'path'
-    param 'Hash[Pattern[/^\w+$/], Any]', 'parameters'
+    param 'String', :path
+    param 'Hash[Pattern[/^\w+$/], Any]', :parameters
     arg_count(1, 2)
   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/inline_epp.rb b/lib/puppet/functions/inline_epp.rb
index a0f063a0e..ce4694929 100644
--- a/lib/puppet/functions/inline_epp.rb
+++ b/lib/puppet/functions/inline_epp.rb
@@ -1,87 +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 4.0.0
 #
 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'
+    param 'String', :template
+    param 'Hash[Pattern[/^\w+$/], Any]', :parameters
     arg_count(1, 2)
   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/match.rb b/lib/puppet/functions/match.rb
index d13d87223..3b23fdb8d 100644
--- a/lib/puppet/functions/match.rb
+++ b/lib/puppet/functions/match.rb
@@ -1,102 +1,102 @@
 # Returns the match result of matching a String or Array[String] with one of:
 #
 # * Regexp
 # * String - transformed to a Regexp
 # * Pattern type
 # * Regexp type
 #
 # Returns An Array with the entire match at index 0, and each subsequent submatch at index 1-n.
 # If there was no match, nil (ie. undef) is returned. If the value to match is an Array, a array
 # with mapped match results is returned.
 #
 # @example matching
 #   "abc123".match(/([a-z]+)[1-9]+/)  # => ["abc"]
 #   "abc123".match(/([a-z]+)([1-9]+)/)  # => ["abc", "123"]
 #
 # See the documentation for "The Puppet Type System" for more information about types.
 # @since 4.0.0
 #
 Puppet::Functions.create_function(:match) do
   dispatch :match do
-    param 'String', 'string'
-    param 'Variant[Any, Type]', 'pattern'
+    param 'String', :string
+    param 'Variant[Any, Type]', :pattern
   end
 
   dispatch :enumerable_match do
-    param 'Array[String]', 'string'
-    param 'Variant[Any, Type]', 'pattern'
+    param 'Array[String]', :string
+    param 'Variant[Any, Type]', :pattern
   end
 
   def initialize(closure_scope, loader)
     super
 
     # Make this visitor shared among all instantiations of this function since it is faster.
     # This can be used because it is not possible to replace
     # a puppet runtime (where this function is) without a reboot. If you model a function in a module after
     # this class, use a regular instance variable instead to enable reloading of the module without reboot
     #
     @@match_visitor   ||= Puppet::Pops::Visitor.new(self, "match", 1, 1)
   end
 
   # Matches given string against given pattern and returns an Array with matches.
   # @param string [String] the string to match
   # @param pattern [String, Regexp, Puppet::Pops::Types::PPatternType, Puppet::Pops::PRegexpType, Array] the pattern
   # @return [Array<String>] matches where first match is the entire match, and index 1-n are captures from left to right
   #
   def match(string, pattern)
     @@match_visitor.visit_this_1(self, pattern, string)
   end
 
   # Matches given Array[String] against given pattern and returns an Array with mapped match results.
   #
   # @param array [Array<String>] the array of strings to match
   # @param pattern [String, Regexp, Puppet::Pops::Types::PPatternType, Puppet::Pops::PRegexpType, Array] the pattern
   # @return [Array<Array<String, nil>>] Array with matches (see {#match}), non matching entries produce a nil entry
   #
   def enumerable_match(array, pattern)
     array.map {|s| match(s, pattern) }
   end
 
   protected
 
   def match_Object(obj, s)
     msg = "match() expects pattern of T, where T is String, Regexp, Regexp[r], Pattern[p], or Array[T]. Got #{obj.class}"
     raise ArgumentError, msg
   end
 
   def match_String(pattern_string, s)
     do_match(s, Regexp.new(pattern_string))
   end
 
   def match_Regexp(regexp, s)
     do_match(s, regexp)
   end
 
   def match_PRegexpType(regexp_t, s)
     raise ArgumentError, "Given Regexp Type has no regular expression" unless regexp_t.pattern
     do_match(s, regexp_t.regexp)
   end
 
   def match_PPatternType(pattern_t, s)
     # Since we want the actual match result (not just a boolean), an iteration over
     # Pattern's regular expressions is needed. (They are of PRegexpType)
     result = nil
     pattern_t.patterns.find {|pattern| result = match(s, pattern) }
     result
   end
 
   # Returns the first matching entry
   def match_Array(array, s)
     result = nil
     array.flatten.find {|entry| result = match(s, entry) }
     result
   end
 
   private
 
   def do_match(s, regexp)
     if result = regexp.match(s)
       result.to_a
     end
   end
 end
diff --git a/lib/puppet/functions/scanf.rb b/lib/puppet/functions/scanf.rb
index 9e4747d93..13cbcce8a 100644
--- a/lib/puppet/functions/scanf.rb
+++ b/lib/puppet/functions/scanf.rb
@@ -1,47 +1,47 @@
 # 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 4.0.0
 #
 Puppet::Functions.create_function(:scanf) do
   require 'scanf'
 
   dispatch :scanf do
-    param 'String', 'data'
-    param 'String', 'format'
+    param 'String', :data
+    param 'String', :format
     optional_block_param
   end
 
   def scanf(data, format, block=nil)
     result = data.scanf(format)
     if !block.nil?
       result = block.call(result)
     end
     result
   end
 end
diff --git a/lib/puppet/functions/with.rb b/lib/puppet/functions/with.rb
index 60004bd30..57777961c 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 4.0.0
 #
 Puppet::Functions.create_function(:with) do
   dispatch :with do
-    param 'Any', 'arg'
+    param 'Any', :arg
     arg_count(0, :default)
     required_block_param
   end
 
   def with(*args)
     args[-1].call(*args[0..-2])
   end
 end
diff --git a/spec/unit/functions/assert_type_spec.rb b/spec/unit/functions/assert_type_spec.rb
index 13b353401..ab3c9c871 100644
--- a/spec/unit/functions/assert_type_spec.rb
+++ b/spec/unit/functions/assert_type_spec.rb
@@ -1,78 +1,78 @@
 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
 
   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)
     expect(expected.to_s).to eql('Optional[String]')
     expect(actual.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'
+        param 'Type', :expected
+        param 'Type', :actual
       end
 
       def func(expected, actual)
         [expected, actual]
       end
     end.new({}, nil)
   end
 end
diff --git a/spec/unit/functions4_spec.rb b/spec/unit/functions4_spec.rb
index 5327abd3f..bdf012ffa 100644
--- a/spec/unit/functions4_spec.rb
+++ b/spec/unit/functions4_spec.rb
@@ -1,648 +1,660 @@
 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 'refuses to create functions with parameters that are not named with a symbol' do
+    expect do
+      Puppet::Functions.create_function('testing') do
+        dispatch :test do
+          param 'Integer', 'not_symbol'
+        end
+        def test(x)
+        end
+      end
+    end.to raise_error(ArgumentError, /Parameter name argument must be a Symbol/)
+  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 = 'Any x, Any y'
     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 = 'Any x, Any y'
     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 = 'Any x, Any y, Any a?, Any b?, Any c{0,}'
       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)
       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)
       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
       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, Float::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
 
       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
 
       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'])
+        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')
+        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')
+        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')
+        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')
+        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
+        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
+        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
       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'
+            param 'Integer', :x
             # block called 'the_block', and using "all_callables"
             required_block_param #(all_callables(), 'the_block')
           end
           def test(x, block)
             # call the block with x
             block.call(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'
+          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'
+        param 'Numeric', :a
+        param 'Numeric', :b
       end
 
       dispatch :min_s do
-        param 'String', 's1'
-        param 'String', 's2'
+        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'
+        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'
+        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'
+        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
       end
     end
   end
 
   def create_function_with_required_block_default_type
     f = Puppet::Functions.create_function('test') do
       dispatch :test do
-        param 'Integer', 'x'
+        param 'Integer', :x
         # use defaults, any callable, name is 'block'
-        required_block_param 'the_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
       end
     end
   end
 
   def create_function_with_required_block_given_type
     f = Puppet::Functions.create_function('test') do
       dispatch :test do
-        param 'Integer', 'x'
+        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
       end
     end
   end
 
   def create_function_with_required_block_fully_specified
     f = Puppet::Functions.create_function('test') do
       dispatch :test do
-        param 'Integer', 'x'
+        param 'Integer', :x
         # use defaults, any callable, name is 'block'
-        required_block_param('Callable', 'the_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
       end
     end
   end
 
   def create_function_with_optional_block_all_defaults
     f = Puppet::Functions.create_function('test') do
       dispatch :test do
-        param 'Integer', 'x'
+        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
       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 48558f930..0232a7b7a 100644
--- a/spec/unit/pops/evaluator/evaluating_parser_spec.rb
+++ b/spec/unit/pops/evaluator/evaluating_parser_spec.rb
@@ -1,1323 +1,1323 @@
 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
 
     # 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 = environment
     @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(:environment) { Puppet::Node::Environment.create(:testing, []) }
   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],
       "[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
           parser.evaluate_string(scope, source, __FILE__).should == 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 1 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,
                          :environments => Puppet::Environments::Static.new(@node.environment)
         }, "gets class parameter 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'
+          param 'Integer', :count
           required_block_param
         end
         def test(count, block)
           block.call(*[].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'
+          param 'Any', :lambda_arg
           required_block_param
         end
         def test(lambda_arg, block)
           block.call(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'
+          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
diff --git a/spec/unit/pops/types/type_calculator_spec.rb b/spec/unit/pops/types/type_calculator_spec.rb
index 2e765719f..c6ec5c509 100644
--- a/spec/unit/pops/types/type_calculator_spec.rb
+++ b/spec/unit/pops/types/type_calculator_spec.rb
@@ -1,1859 +1,1859 @@
 require 'spec_helper'
 require 'puppet/pops'
 
 describe 'The type calculator' do
   let(:calculator) {  Puppet::Pops::Types::TypeCalculator.new() }
 
   def range_t(from, to)
    t = Puppet::Pops::Types::PIntegerType.new
    t.from = from
    t.to = to
    t
   end
   def constrained_t(t, from, to)
     Puppet::Pops::Types::TypeFactory.constrain_size(t, from, to)
   end
 
   def pattern_t(*patterns)
     Puppet::Pops::Types::TypeFactory.pattern(*patterns)
   end
 
   def regexp_t(pattern)
     Puppet::Pops::Types::TypeFactory.regexp(pattern)
   end
 
   def string_t(*strings)
     Puppet::Pops::Types::TypeFactory.string(*strings)
   end
 
   def callable_t(*params)
     Puppet::Pops::Types::TypeFactory.callable(*params)
   end
   def all_callables_t(*params)
     Puppet::Pops::Types::TypeFactory.all_callables()
   end
 
   def with_block_t(callable_t, *params)
     Puppet::Pops::Types::TypeFactory.with_block(callable_t, *params)
   end
 
   def with_optional_block_t(callable_t, *params)
     Puppet::Pops::Types::TypeFactory.with_optional_block(callable_t, *params)
   end
 
   def enum_t(*strings)
     Puppet::Pops::Types::TypeFactory.enum(*strings)
   end
 
   def variant_t(*types)
     Puppet::Pops::Types::TypeFactory.variant(*types)
   end
 
   def integer_t()
     Puppet::Pops::Types::TypeFactory.integer()
   end
 
   def array_t(t)
     Puppet::Pops::Types::TypeFactory.array_of(t)
   end
 
   def hash_t(k,v)
     Puppet::Pops::Types::TypeFactory.hash_of(v, k)
   end
 
   def data_t()
     Puppet::Pops::Types::TypeFactory.data()
   end
 
   def factory()
     Puppet::Pops::Types::TypeFactory
   end
 
   def collection_t()
     Puppet::Pops::Types::TypeFactory.collection()
   end
 
   def tuple_t(*types)
     Puppet::Pops::Types::TypeFactory.tuple(*types)
   end
 
   def struct_t(type_hash)
     Puppet::Pops::Types::TypeFactory.struct(type_hash)
   end
 
   def object_t
     Puppet::Pops::Types::TypeFactory.any()
   end
 
   def unit_t
     # Cannot be created via factory, the type is private to the type system
     Puppet::Pops::Types::PUnitType.new
   end
 
   def types
     Puppet::Pops::Types
   end
 
   shared_context "types_setup" do
 
     # Do not include the special type Unit in this list
     def all_types
       [ Puppet::Pops::Types::PAnyType,
         Puppet::Pops::Types::PNilType,
         Puppet::Pops::Types::PDataType,
         Puppet::Pops::Types::PScalarType,
         Puppet::Pops::Types::PStringType,
         Puppet::Pops::Types::PNumericType,
         Puppet::Pops::Types::PIntegerType,
         Puppet::Pops::Types::PFloatType,
         Puppet::Pops::Types::PRegexpType,
         Puppet::Pops::Types::PBooleanType,
         Puppet::Pops::Types::PCollectionType,
         Puppet::Pops::Types::PArrayType,
         Puppet::Pops::Types::PHashType,
         Puppet::Pops::Types::PRuntimeType,
         Puppet::Pops::Types::PHostClassType,
         Puppet::Pops::Types::PResourceType,
         Puppet::Pops::Types::PPatternType,
         Puppet::Pops::Types::PEnumType,
         Puppet::Pops::Types::PVariantType,
         Puppet::Pops::Types::PStructType,
         Puppet::Pops::Types::PTupleType,
         Puppet::Pops::Types::PCallableType,
         Puppet::Pops::Types::PType,
         Puppet::Pops::Types::POptionalType,
         Puppet::Pops::Types::PDefaultType,
       ]
     end
 
     def scalar_types
       # PVariantType is also scalar, if its types are all Scalar
       [
         Puppet::Pops::Types::PScalarType,
         Puppet::Pops::Types::PStringType,
         Puppet::Pops::Types::PNumericType,
         Puppet::Pops::Types::PIntegerType,
         Puppet::Pops::Types::PFloatType,
         Puppet::Pops::Types::PRegexpType,
         Puppet::Pops::Types::PBooleanType,
         Puppet::Pops::Types::PPatternType,
         Puppet::Pops::Types::PEnumType,
       ]
     end
 
     def numeric_types
       # PVariantType is also numeric, if its types are all numeric
       [
         Puppet::Pops::Types::PNumericType,
         Puppet::Pops::Types::PIntegerType,
         Puppet::Pops::Types::PFloatType,
       ]
     end
 
     def string_types
       # PVariantType is also string type, if its types are all compatible
       [
         Puppet::Pops::Types::PStringType,
         Puppet::Pops::Types::PPatternType,
         Puppet::Pops::Types::PEnumType,
       ]
     end
 
     def collection_types
       # PVariantType is also string type, if its types are all compatible
       [
         Puppet::Pops::Types::PCollectionType,
         Puppet::Pops::Types::PHashType,
         Puppet::Pops::Types::PArrayType,
         Puppet::Pops::Types::PStructType,
         Puppet::Pops::Types::PTupleType,
       ]
     end
 
     def data_compatible_types
       result = scalar_types
       result << Puppet::Pops::Types::PDataType
       result << array_t(types::PDataType.new)
       result << types::TypeFactory.hash_of_data
       result << Puppet::Pops::Types::PNilType
       tmp = tuple_t(types::PDataType.new)
       result << (tmp)
       tmp.size_type = range_t(0, nil)
       result
     end
 
     def type_from_class(c)
       c.is_a?(Class) ? c.new : c
     end
   end
 
   context 'when inferring ruby' do
 
     it 'fixnum translates to PIntegerType' do
       calculator.infer(1).class.should == Puppet::Pops::Types::PIntegerType
     end
 
     it 'large fixnum (or bignum depending on architecture) translates to PIntegerType' do
       calculator.infer(2**33).class.should == Puppet::Pops::Types::PIntegerType
     end
 
     it 'float translates to PFloatType' do
       calculator.infer(1.3).class.should == Puppet::Pops::Types::PFloatType
     end
 
     it 'string translates to PStringType' do
       calculator.infer('foo').class.should == Puppet::Pops::Types::PStringType
     end
 
     it 'inferred string type knows the string value' do
       t = calculator.infer('foo')
       t.class.should == Puppet::Pops::Types::PStringType
       t.values.should == ['foo']
     end
 
     it 'boolean true translates to PBooleanType' do
       calculator.infer(true).class.should == Puppet::Pops::Types::PBooleanType
     end
 
     it 'boolean false translates to PBooleanType' do
       calculator.infer(false).class.should == Puppet::Pops::Types::PBooleanType
     end
 
     it 'regexp translates to PRegexpType' do
       calculator.infer(/^a regular expression$/).class.should == Puppet::Pops::Types::PRegexpType
     end
 
     it 'nil translates to PNilType' do
       calculator.infer(nil).class.should == Puppet::Pops::Types::PNilType
     end
 
     it ':undef translates to PRuntimeType' do
       calculator.infer(:undef).class.should == Puppet::Pops::Types::PRuntimeType
     end
 
     it 'an instance of class Foo translates to PRuntimeType[ruby, Foo]' do
       class Foo
       end
 
       t = calculator.infer(Foo.new)
       t.class.should == Puppet::Pops::Types::PRuntimeType
       t.runtime.should == :ruby
       t.runtime_type_name.should == 'Foo'
     end
 
     context 'array' do
       it 'translates to PArrayType' do
         calculator.infer([1,2]).class.should == Puppet::Pops::Types::PArrayType
       end
 
       it 'with fixnum values translates to PArrayType[PIntegerType]' do
         calculator.infer([1,2]).element_type.class.should == Puppet::Pops::Types::PIntegerType
       end
 
       it 'with 32 and 64 bit integer values translates to PArrayType[PIntegerType]' do
         calculator.infer([1,2**33]).element_type.class.should == Puppet::Pops::Types::PIntegerType
       end
 
       it 'Range of integer values are computed' do
         t = calculator.infer([-3,0,42]).element_type
         t.class.should == Puppet::Pops::Types::PIntegerType
         t.from.should == -3
         t.to.should == 42
       end
 
       it "Compound string values are computed" do
         t = calculator.infer(['a','b', 'c']).element_type
         t.class.should == Puppet::Pops::Types::PStringType
         t.values.should == ['a', 'b', 'c']
       end
 
       it 'with fixnum and float values translates to PArrayType[PNumericType]' do
         calculator.infer([1,2.0]).element_type.class.should == Puppet::Pops::Types::PNumericType
       end
 
       it 'with fixnum and string values translates to PArrayType[PScalarType]' do
         calculator.infer([1,'two']).element_type.class.should == Puppet::Pops::Types::PScalarType
       end
 
       it 'with float and string values translates to PArrayType[PScalarType]' do
         calculator.infer([1.0,'two']).element_type.class.should == Puppet::Pops::Types::PScalarType
       end
 
       it 'with fixnum, float, and string values translates to PArrayType[PScalarType]' do
         calculator.infer([1, 2.0,'two']).element_type.class.should == Puppet::Pops::Types::PScalarType
       end
 
       it 'with fixnum and regexp values translates to PArrayType[PScalarType]' do
         calculator.infer([1, /two/]).element_type.class.should == Puppet::Pops::Types::PScalarType
       end
 
       it 'with string and regexp values translates to PArrayType[PScalarType]' do
         calculator.infer(['one', /two/]).element_type.class.should == Puppet::Pops::Types::PScalarType
       end
 
       it 'with string and symbol values translates to PArrayType[PAnyType]' do
         calculator.infer(['one', :two]).element_type.class.should == Puppet::Pops::Types::PAnyType
       end
 
       it 'with fixnum and nil values translates to PArrayType[PIntegerType]' do
         calculator.infer([1, nil]).element_type.class.should == Puppet::Pops::Types::PIntegerType
       end
 
       it 'with arrays of string values translates to PArrayType[PArrayType[PStringType]]' do
         et = calculator.infer([['first' 'array'], ['second','array']])
         et.class.should == Puppet::Pops::Types::PArrayType
         et = et.element_type
         et.class.should == Puppet::Pops::Types::PArrayType
         et = et.element_type
         et.class.should == Puppet::Pops::Types::PStringType
       end
 
       it 'with array of string values and array of fixnums translates to PArrayType[PArrayType[PScalarType]]' do
         et = calculator.infer([['first' 'array'], [1,2]])
         et.class.should == Puppet::Pops::Types::PArrayType
         et = et.element_type
         et.class.should == Puppet::Pops::Types::PArrayType
         et = et.element_type
         et.class.should == Puppet::Pops::Types::PScalarType
       end
 
       it 'with hashes of string values translates to PArrayType[PHashType[PStringType]]' do
         et = calculator.infer([{:first => 'first', :second => 'second' }, {:first => 'first', :second => 'second' }])
         et.class.should == Puppet::Pops::Types::PArrayType
         et = et.element_type
         et.class.should == Puppet::Pops::Types::PHashType
         et = et.element_type
         et.class.should == Puppet::Pops::Types::PStringType
       end
 
       it 'with hash of string values and hash of fixnums translates to PArrayType[PHashType[PScalarType]]' do
         et = calculator.infer([{:first => 'first', :second => 'second' }, {:first => 1, :second => 2 }])
         et.class.should == Puppet::Pops::Types::PArrayType
         et = et.element_type
         et.class.should == Puppet::Pops::Types::PHashType
         et = et.element_type
         et.class.should == Puppet::Pops::Types::PScalarType
       end
     end
 
     context 'hash' do
       it 'translates to PHashType' do
         calculator.infer({:first => 1, :second => 2}).class.should == Puppet::Pops::Types::PHashType
       end
 
       it 'with symbolic keys translates to PHashType[PRuntimeType[ruby, Symbol], value]' do
         k = calculator.infer({:first => 1, :second => 2}).key_type
         k.class.should == Puppet::Pops::Types::PRuntimeType
         k.runtime.should == :ruby
         k.runtime_type_name.should == 'Symbol'
       end
 
       it 'with string keys translates to PHashType[PStringType, value]' do
         calculator.infer({'first' => 1, 'second' => 2}).key_type.class.should == Puppet::Pops::Types::PStringType
       end
 
       it 'with fixnum values translates to PHashType[key, PIntegerType]' do
         calculator.infer({:first => 1, :second => 2}).element_type.class.should == Puppet::Pops::Types::PIntegerType
       end
     end
 
   end
 
   context 'patterns' do
     it "constructs a PPatternType" do
       t = pattern_t('a(b)c')
       t.class.should == Puppet::Pops::Types::PPatternType
       t.patterns.size.should == 1
       t.patterns[0].class.should == Puppet::Pops::Types::PRegexpType
       t.patterns[0].pattern.should == 'a(b)c'
       t.patterns[0].regexp.match('abc')[1].should == 'b'
     end
 
     it "constructs a PStringType with multiple strings" do
       t = string_t('a', 'b', 'c', 'abc')
       t.values.should == ['a', 'b', 'c', 'abc']
     end
   end
 
   # Deal with cases not covered by computing common type
   context 'when computing common type' do
     it 'computes given resource type commonality' do
       r1 = Puppet::Pops::Types::PResourceType.new()
       r1.type_name = 'File'
       r2 = Puppet::Pops::Types::PResourceType.new()
       r2.type_name = 'File'
       calculator.string(calculator.common_type(r1, r2)).should == "File"
 
       r2 = Puppet::Pops::Types::PResourceType.new()
       r2.type_name = 'File'
       r2.title = '/tmp/foo'
       calculator.string(calculator.common_type(r1, r2)).should == "File"
 
       r1 = Puppet::Pops::Types::PResourceType.new()
       r1.type_name = 'File'
       r1.title = '/tmp/foo'
       calculator.string(calculator.common_type(r1, r2)).should == "File['/tmp/foo']"
 
       r1 = Puppet::Pops::Types::PResourceType.new()
       r1.type_name = 'File'
       r1.title = '/tmp/bar'
       calculator.string(calculator.common_type(r1, r2)).should == "File"
 
       r2 = Puppet::Pops::Types::PResourceType.new()
       r2.type_name = 'Package'
       r2.title = 'apache'
       calculator.string(calculator.common_type(r1, r2)).should == "Resource"
     end
 
     it 'computes given hostclass type commonality' do
       r1 = Puppet::Pops::Types::PHostClassType.new()
       r1.class_name = 'foo'
       r2 = Puppet::Pops::Types::PHostClassType.new()
       r2.class_name = 'foo'
       calculator.string(calculator.common_type(r1, r2)).should == "Class[foo]"
 
       r2 = Puppet::Pops::Types::PHostClassType.new()
       r2.class_name = 'bar'
       calculator.string(calculator.common_type(r1, r2)).should == "Class"
 
       r2 = Puppet::Pops::Types::PHostClassType.new()
       calculator.string(calculator.common_type(r1, r2)).should == "Class"
 
       r1 = Puppet::Pops::Types::PHostClassType.new()
       calculator.string(calculator.common_type(r1, r2)).should == "Class"
     end
 
     it 'computes pattern commonality' do
       t1 = pattern_t('abc')
       t2 = pattern_t('xyz')
       common_t = calculator.common_type(t1,t2)
       common_t.class.should == Puppet::Pops::Types::PPatternType
       common_t.patterns.map { |pr| pr.pattern }.should == ['abc', 'xyz']
       calculator.string(common_t).should == "Pattern[/abc/, /xyz/]"
     end
 
     it 'computes enum commonality to value set sum' do
       t1 = enum_t('a', 'b', 'c')
       t2 = enum_t('x', 'y', 'z')
       common_t = calculator.common_type(t1, t2)
       common_t.should == enum_t('a', 'b', 'c', 'x', 'y', 'z')
     end
 
     it 'computed variant commonality to type union where added types are not sub-types' do
       a_t1 = integer_t()
       a_t2 = enum_t('b')
       v_a = variant_t(a_t1, a_t2)
       b_t1 = enum_t('a')
       v_b = variant_t(b_t1)
       common_t = calculator.common_type(v_a, v_b)
       common_t.class.should == Puppet::Pops::Types::PVariantType
       Set.new(common_t.types).should  == Set.new([a_t1, a_t2, b_t1])
     end
 
     it 'computed variant commonality to type union where added types are sub-types' do
       a_t1 = integer_t()
       a_t2 = string_t()
       v_a = variant_t(a_t1, a_t2)
       b_t1 = enum_t('a')
       v_b = variant_t(b_t1)
       common_t = calculator.common_type(v_a, v_b)
       common_t.class.should == Puppet::Pops::Types::PVariantType
       Set.new(common_t.types).should  == Set.new([a_t1, a_t2])
     end
 
     context "of callables" do
       it 'incompatible instances => generic callable' do
         t1 = callable_t(String)
         t2 = callable_t(Integer)
         common_t = calculator.common_type(t1, t2)
         expect(common_t.class).to be(Puppet::Pops::Types::PCallableType)
         expect(common_t.param_types).to be_nil
         expect(common_t.block_type).to be_nil
       end
 
       it 'compatible instances => the most specific' do
         t1 = callable_t(String)
         scalar_t = Puppet::Pops::Types::PScalarType.new
         t2 = callable_t(scalar_t)
         common_t = calculator.common_type(t1, t2)
         expect(common_t.class).to be(Puppet::Pops::Types::PCallableType)
         expect(common_t.param_types.class).to be(Puppet::Pops::Types::PTupleType)
         expect(common_t.param_types.types).to eql([string_t])
         expect(common_t.block_type).to be_nil
       end
 
       it 'block_type is included in the check (incompatible block)' do
         t1 = with_block_t(callable_t(String), String)
         t2 = with_block_t(callable_t(String), Integer)
         common_t = calculator.common_type(t1, t2)
         expect(common_t.class).to be(Puppet::Pops::Types::PCallableType)
         expect(common_t.param_types).to be_nil
         expect(common_t.block_type).to be_nil
       end
 
       it 'block_type is included in the check (compatible block)' do
         t1 = with_block_t(callable_t(String), String)
         scalar_t = Puppet::Pops::Types::PScalarType.new
         t2 = with_block_t(callable_t(String), scalar_t)
         common_t = calculator.common_type(t1, t2)
         expect(common_t.param_types.class).to be(Puppet::Pops::Types::PTupleType)
         expect(common_t.block_type).to eql(callable_t(scalar_t))
       end
     end
   end
 
   context 'computes assignability' do
     include_context "types_setup"
 
     context 'for Unit, such that' do
       it 'all types are assignable to Unit' do
         t = Puppet::Pops::Types::PUnitType.new()
         all_types.each { |t2| t2.new.should be_assignable_to(t) }
       end
 
       it 'Unit is assignable to all other types' do
         t = Puppet::Pops::Types::PUnitType.new()
         all_types.each { |t2| t.should be_assignable_to(t2.new) }
       end
 
       it 'Unit is assignable to Unit' do
         t = Puppet::Pops::Types::PUnitType.new()
         t2 = Puppet::Pops::Types::PUnitType.new()
         t.should be_assignable_to(t2)
       end
     end
 
     context "for Any, such that" do
       it 'all types are assignable to Any' do
         t = Puppet::Pops::Types::PAnyType.new()
         all_types.each { |t2| t2.new.should be_assignable_to(t) }
       end
 
       it 'Any is not assignable to anything but Any' do
         tested_types = all_types() - [Puppet::Pops::Types::PAnyType]
         t = Puppet::Pops::Types::PAnyType.new()
         tested_types.each { |t2| t.should_not be_assignable_to(t2.new) }
       end
     end
 
     context "for Data, such that" do
       it 'all scalars + array and hash are assignable to Data' do
         t = Puppet::Pops::Types::PDataType.new()
         data_compatible_types.each { |t2|
           type_from_class(t2).should be_assignable_to(t)
         }
       end
 
       it 'a Variant of scalar, hash, or array is assignable to Data' do
         t = Puppet::Pops::Types::PDataType.new()
         data_compatible_types.each { |t2| variant_t(type_from_class(t2)).should be_assignable_to(t) }
       end
 
       it 'Data is not assignable to any of its subtypes' do
         t = Puppet::Pops::Types::PDataType.new()
         types_to_test = data_compatible_types- [Puppet::Pops::Types::PDataType]
         types_to_test.each {|t2| t.should_not be_assignable_to(type_from_class(t2)) }
       end
 
       it 'Data is not assignable to a Variant of Data subtype' do
         t = Puppet::Pops::Types::PDataType.new()
         types_to_test = data_compatible_types- [Puppet::Pops::Types::PDataType]
         types_to_test.each { |t2| t.should_not be_assignable_to(variant_t(type_from_class(t2))) }
       end
 
       it 'Data is not assignable to any disjunct type' do
         tested_types = all_types - [Puppet::Pops::Types::PAnyType, Puppet::Pops::Types::PDataType] - scalar_types
         t = Puppet::Pops::Types::PDataType.new()
         tested_types.each {|t2| t.should_not be_assignable_to(t2.new) }
       end
     end
 
     context "for Scalar, such that" do
       it "all scalars are assignable to Scalar" do
         t = Puppet::Pops::Types::PScalarType.new()
         scalar_types.each {|t2| t2.new.should be_assignable_to(t) }
       end
 
       it 'Scalar is not assignable to any of its subtypes' do
         t = Puppet::Pops::Types::PScalarType.new()
         types_to_test = scalar_types - [Puppet::Pops::Types::PScalarType]
         types_to_test.each {|t2| t.should_not be_assignable_to(t2.new) }
       end
 
       it 'Scalar is not assignable to any disjunct type' do
         tested_types = all_types - [Puppet::Pops::Types::PAnyType, Puppet::Pops::Types::PDataType] - scalar_types
         t = Puppet::Pops::Types::PScalarType.new()
         tested_types.each {|t2| t.should_not be_assignable_to(t2.new) }
       end
     end
 
     context "for Numeric, such that" do
       it "all numerics are assignable to Numeric" do
         t = Puppet::Pops::Types::PNumericType.new()
         numeric_types.each {|t2| t2.new.should be_assignable_to(t) }
       end
 
       it 'Numeric is not assignable to any of its subtypes' do
         t = Puppet::Pops::Types::PNumericType.new()
         types_to_test = numeric_types - [Puppet::Pops::Types::PNumericType]
         types_to_test.each {|t2| t.should_not be_assignable_to(t2.new) }
       end
 
       it 'Numeric is not assignable to any disjunct type' do
         tested_types = all_types - [
           Puppet::Pops::Types::PAnyType,
           Puppet::Pops::Types::PDataType,
           Puppet::Pops::Types::PScalarType,
           ] - numeric_types
         t = Puppet::Pops::Types::PNumericType.new()
         tested_types.each {|t2| t.should_not be_assignable_to(t2.new) }
       end
     end
 
     context "for Collection, such that" do
       it "all collections are assignable to Collection" do
         t = Puppet::Pops::Types::PCollectionType.new()
         collection_types.each {|t2| t2.new.should be_assignable_to(t) }
       end
 
       it 'Collection is not assignable to any of its subtypes' do
         t = Puppet::Pops::Types::PCollectionType.new()
         types_to_test = collection_types - [Puppet::Pops::Types::PCollectionType]
         types_to_test.each {|t2| t.should_not be_assignable_to(t2.new) }
       end
 
       it 'Collection is not assignable to any disjunct type' do
         tested_types = all_types - [Puppet::Pops::Types::PAnyType] - collection_types
         t = Puppet::Pops::Types::PCollectionType.new()
         tested_types.each {|t2| t.should_not be_assignable_to(t2.new) }
       end
     end
 
     context "for Array, such that" do
       it "Array is not assignable to non Array based Collection type" do
         t = Puppet::Pops::Types::PArrayType.new()
         tested_types = collection_types - [
           Puppet::Pops::Types::PCollectionType,
           Puppet::Pops::Types::PArrayType,
           Puppet::Pops::Types::PTupleType]
         tested_types.each {|t2| t.should_not be_assignable_to(t2.new) }
       end
 
       it 'Array is not assignable to any disjunct type' do
         tested_types = all_types - [
           Puppet::Pops::Types::PAnyType,
           Puppet::Pops::Types::PDataType] - collection_types
         t = Puppet::Pops::Types::PArrayType.new()
         tested_types.each {|t2| t.should_not be_assignable_to(t2.new) }
       end
     end
 
     context "for Hash, such that" do
       it "Hash is not assignable to any other Collection type" do
         t = Puppet::Pops::Types::PHashType.new()
         tested_types = collection_types - [
           Puppet::Pops::Types::PCollectionType,
           Puppet::Pops::Types::PStructType,
           Puppet::Pops::Types::PHashType]
         tested_types.each {|t2| t.should_not be_assignable_to(t2.new) }
       end
 
       it 'Hash is not assignable to any disjunct type' do
         tested_types = all_types - [
           Puppet::Pops::Types::PAnyType,
           Puppet::Pops::Types::PDataType] - collection_types
         t = Puppet::Pops::Types::PHashType.new()
         tested_types.each {|t2| t.should_not be_assignable_to(t2.new) }
       end
     end
 
     context "for Tuple, such that" do
       it "Tuple is not assignable to any other non Array based Collection type" do
         t = Puppet::Pops::Types::PTupleType.new()
         tested_types = collection_types - [
           Puppet::Pops::Types::PCollectionType,
           Puppet::Pops::Types::PTupleType,
           Puppet::Pops::Types::PArrayType]
         tested_types.each {|t2| t.should_not be_assignable_to(t2.new) }
       end
 
       it 'Tuple is not assignable to any disjunct type' do
         tested_types = all_types - [
           Puppet::Pops::Types::PAnyType,
           Puppet::Pops::Types::PDataType] - collection_types
         t = Puppet::Pops::Types::PTupleType.new()
         tested_types.each {|t2| t.should_not be_assignable_to(t2.new) }
       end
     end
 
     context "for Struct, such that" do
       it "Struct is not assignable to any other non Hashed based Collection type" do
         t = Puppet::Pops::Types::PStructType.new()
         tested_types = collection_types - [
           Puppet::Pops::Types::PCollectionType,
           Puppet::Pops::Types::PStructType,
           Puppet::Pops::Types::PHashType]
         tested_types.each {|t2| t.should_not be_assignable_to(t2.new) }
       end
 
       it 'Struct is not assignable to any disjunct type' do
         tested_types = all_types - [
           Puppet::Pops::Types::PAnyType,
           Puppet::Pops::Types::PDataType] - collection_types
         t = Puppet::Pops::Types::PStructType.new()
         tested_types.each {|t2| t.should_not be_assignable_to(t2.new) }
       end
     end
 
     context "for Callable, such that" do
       it "Callable is not assignable to any disjunct type" do
         t = Puppet::Pops::Types::PCallableType.new()
         tested_types = all_types - [
           Puppet::Pops::Types::PCallableType,
           Puppet::Pops::Types::PAnyType]
         tested_types.each {|t2| t.should_not be_assignable_to(t2.new) }
       end
     end
 
     it 'should recognize mapped ruby types' do
       { Integer    => Puppet::Pops::Types::PIntegerType.new,
         Fixnum     => Puppet::Pops::Types::PIntegerType.new,
         Bignum     => Puppet::Pops::Types::PIntegerType.new,
         Float      => Puppet::Pops::Types::PFloatType.new,
         Numeric    => Puppet::Pops::Types::PNumericType.new,
         NilClass   => Puppet::Pops::Types::PNilType.new,
         TrueClass  => Puppet::Pops::Types::PBooleanType.new,
         FalseClass => Puppet::Pops::Types::PBooleanType.new,
         String     => Puppet::Pops::Types::PStringType.new,
         Regexp     => Puppet::Pops::Types::PRegexpType.new,
         Regexp     => Puppet::Pops::Types::PRegexpType.new,
         Array      => Puppet::Pops::Types::TypeFactory.array_of_data(),
         Hash       => Puppet::Pops::Types::TypeFactory.hash_of_data()
       }.each do |ruby_type, puppet_type |
           ruby_type.should be_assignable_to(puppet_type)
       end
     end
 
     context 'when dealing with integer ranges' do
       it 'should accept an equal range' do
         calculator.assignable?(range_t(2,5), range_t(2,5)).should == true
       end
 
       it 'should accept an equal reverse range' do
         calculator.assignable?(range_t(2,5), range_t(5,2)).should == true
       end
 
       it 'should accept a narrower range' do
         calculator.assignable?(range_t(2,10), range_t(3,5)).should == true
       end
 
       it 'should accept a narrower reverse range' do
         calculator.assignable?(range_t(2,10), range_t(5,3)).should == true
       end
 
       it 'should reject a wider range' do
         calculator.assignable?(range_t(3,5), range_t(2,10)).should == false
       end
 
       it 'should reject a wider reverse range' do
         calculator.assignable?(range_t(3,5), range_t(10,2)).should == false
       end
 
       it 'should reject a partially overlapping range' do
         calculator.assignable?(range_t(3,5), range_t(2,4)).should == false
         calculator.assignable?(range_t(3,5), range_t(4,6)).should == false
       end
 
       it 'should reject a partially overlapping reverse range' do
         calculator.assignable?(range_t(3,5), range_t(4,2)).should == false
         calculator.assignable?(range_t(3,5), range_t(6,4)).should == false
       end
     end
 
     context 'when dealing with patterns' do
       it 'should accept a string matching a pattern' do
         p_t = pattern_t('abc')
         p_s = string_t('XabcY')
         calculator.assignable?(p_t, p_s).should == true
       end
 
       it 'should accept a regexp matching a pattern' do
         p_t = pattern_t(/abc/)
         p_s = string_t('XabcY')
         calculator.assignable?(p_t, p_s).should == true
       end
 
       it 'should accept a pattern matching a pattern' do
         p_t = pattern_t(pattern_t('abc'))
         p_s = string_t('XabcY')
         calculator.assignable?(p_t, p_s).should == true
       end
 
       it 'should accept a regexp matching a pattern' do
         p_t = pattern_t(regexp_t('abc'))
         p_s = string_t('XabcY')
         calculator.assignable?(p_t, p_s).should == true
       end
 
       it 'should accept a string matching all patterns' do
         p_t = pattern_t('abc', 'ab', 'c')
         p_s = string_t('XabcY')
         calculator.assignable?(p_t, p_s).should == true
       end
 
       it 'should accept multiple strings if they all match any patterns' do
         p_t = pattern_t('X', 'Y', 'abc')
         p_s = string_t('Xa', 'aY', 'abc')
         calculator.assignable?(p_t, p_s).should == true
       end
 
       it 'should reject a string not matching any patterns' do
         p_t = pattern_t('abc', 'ab', 'c')
         p_s = string_t('XqqqY')
         calculator.assignable?(p_t, p_s).should == false
       end
 
       it 'should reject multiple strings if not all match any patterns' do
         p_t = pattern_t('abc', 'ab', 'c', 'q')
         p_s = string_t('X', 'Y', 'Z')
         calculator.assignable?(p_t, p_s).should == false
       end
 
       it 'should accept enum matching patterns as instanceof' do
         enum = enum_t('XS', 'S', 'M', 'L' 'XL', 'XXL')
         pattern = pattern_t('S', 'M', 'L')
         calculator.assignable?(pattern, enum).should  == true
       end
 
       it 'pattern should accept a variant where all variants are acceptable' do
         pattern = pattern_t(/^\w+$/)
         calculator.assignable?(pattern, variant_t(string_t('a'), string_t('b'))).should == true
       end
 
       it 'pattern representing all patterns should accept any pattern' do
         calculator.assignable?(pattern_t(), pattern_t('a')).should == true
         calculator.assignable?(pattern_t(), pattern_t()).should == true
       end
 
       it 'pattern representing all patterns should accept any enum' do
         calculator.assignable?(pattern_t(), enum_t('a')).should == true
         calculator.assignable?(pattern_t(), enum_t()).should == true
       end
 
       it 'pattern representing all patterns should accept any string' do
         calculator.assignable?(pattern_t(), string_t('a')).should == true
         calculator.assignable?(pattern_t(), string_t()).should == true
       end
 
     end
 
     context 'when dealing with enums' do
       it 'should accept a string with matching content' do
         calculator.assignable?(enum_t('a', 'b'), string_t('a')).should == true
         calculator.assignable?(enum_t('a', 'b'), string_t('b')).should == true
         calculator.assignable?(enum_t('a', 'b'), string_t('c')).should == false
       end
 
       it 'should accept an enum with matching enum' do
         calculator.assignable?(enum_t('a', 'b'), enum_t('a', 'b')).should == true
         calculator.assignable?(enum_t('a', 'b'), enum_t('a')).should == true
         calculator.assignable?(enum_t('a', 'b'), enum_t('c')).should == false
       end
 
       it 'non parameterized enum accepts any other enum but not the reverse' do
         calculator.assignable?(enum_t(), enum_t('a')).should == true
         calculator.assignable?(enum_t('a'), enum_t()).should == false
       end
 
       it 'enum should accept a variant where all variants are acceptable' do
         enum = enum_t('a', 'b')
         calculator.assignable?(enum, variant_t(string_t('a'), string_t('b'))).should == true
       end
     end
 
     context 'when dealing with string and enum combinations' do
       it 'should accept assigning any enum to unrestricted string' do
         calculator.assignable?(string_t(), enum_t('blue')).should == true
         calculator.assignable?(string_t(), enum_t('blue', 'red')).should == true
       end
 
       it 'should not accept assigning longer enum value to size restricted string' do
         calculator.assignable?(constrained_t(string_t(),2,2), enum_t('a','blue')).should == false
       end
 
       it 'should accept assigning any string to empty enum' do
         calculator.assignable?(enum_t(), string_t()).should == true
       end
 
       it 'should accept assigning empty enum to any string' do
         calculator.assignable?(string_t(), enum_t()).should == true
       end
 
       it 'should not accept assigning empty enum to size constrained string' do
         calculator.assignable?(constrained_t(string_t(),2,2), enum_t()).should == false
       end
     end
 
     context 'when dealing with string/pattern/enum combinations' do
       it 'any string is equal to any enum is equal to any pattern' do
         calculator.assignable?(string_t(), enum_t()).should == true
         calculator.assignable?(string_t(), pattern_t()).should == true
         calculator.assignable?(enum_t(), string_t()).should == true
         calculator.assignable?(enum_t(), pattern_t()).should == true
         calculator.assignable?(pattern_t(), string_t()).should == true
         calculator.assignable?(pattern_t(), enum_t()).should == true
       end
     end
 
     context 'when dealing with tuples' do
       it 'matches empty tuples' do
         tuple1 = tuple_t()
         tuple2 = tuple_t()
 
         calculator.assignable?(tuple1, tuple2).should == true
         calculator.assignable?(tuple2, tuple1).should == true
       end
 
       it 'accepts an empty tuple as assignable to a tuple with a min size of 0' do
         tuple1 = tuple_t(Object)
         factory.constrain_size(tuple1, 0, :default)
         tuple2 = tuple_t()
 
         calculator.assignable?(tuple1, tuple2).should == true
         calculator.assignable?(tuple2, tuple1).should == false
       end
 
       it 'should accept matching tuples' do
         tuple1 = tuple_t(1,2)
         tuple2 = tuple_t(Integer,Integer)
         calculator.assignable?(tuple1, tuple2).should == true
         calculator.assignable?(tuple2, tuple1).should == true
       end
 
       it 'should accept matching tuples where one is more general than the other' do
         tuple1 = tuple_t(1,2)
         tuple2 = tuple_t(Numeric,Numeric)
         calculator.assignable?(tuple1, tuple2).should == false
         calculator.assignable?(tuple2, tuple1).should == true
       end
 
       it 'should accept ranged tuples' do
         tuple1 = tuple_t(1)
         factory.constrain_size(tuple1, 5, 5)
         tuple2 = tuple_t(Integer,Integer, Integer, Integer, Integer)
         calculator.assignable?(tuple1, tuple2).should == true
         calculator.assignable?(tuple2, tuple1).should == true
       end
 
       it 'should reject ranged tuples when ranges does not match' do
         tuple1 = tuple_t(1)
         factory.constrain_size(tuple1, 4, 5)
         tuple2 = tuple_t(Integer,Integer, Integer, Integer, Integer)
         calculator.assignable?(tuple1, tuple2).should == true
         calculator.assignable?(tuple2, tuple1).should == false
       end
 
       it 'should reject ranged tuples when ranges does not match (using infinite upper bound)' do
         tuple1 = tuple_t(1)
         factory.constrain_size(tuple1, 4, :default)
         tuple2 = tuple_t(Integer,Integer, Integer, Integer, Integer)
         calculator.assignable?(tuple1, tuple2).should == true
         calculator.assignable?(tuple2, tuple1).should == false
       end
 
       it 'should accept matching tuples with optional entries by repeating last' do
         tuple1 = tuple_t(1,2)
         factory.constrain_size(tuple1, 0, :default)
         tuple2 = tuple_t(Numeric,Numeric)
         factory.constrain_size(tuple2, 0, :default)
         calculator.assignable?(tuple1, tuple2).should == false
         calculator.assignable?(tuple2, tuple1).should == true
       end
 
       it 'should accept matching tuples with optional entries' do
         tuple1 = tuple_t(Integer, Integer, String)
         factory.constrain_size(tuple1, 1, 3)
         array2 = factory.constrain_size(array_t(Integer),2,2)
         calculator.assignable?(tuple1, array2).should == true
         factory.constrain_size(tuple1, 3, 3)
         calculator.assignable?(tuple1, array2).should == false
       end
 
       it 'should accept matching array' do
         tuple1 = tuple_t(1,2)
         array = array_t(Integer)
         factory.constrain_size(array, 2, 2)
         calculator.assignable?(tuple1, array).should == true
         calculator.assignable?(array, tuple1).should == true
       end
 
       it 'should accept empty array when tuple allows min of 0' do
         tuple1 = tuple_t(Integer)
         factory.constrain_size(tuple1, 0, 1)
 
         array = array_t(Integer)
         factory.constrain_size(array, 0, 0)
 
         calculator.assignable?(tuple1, array).should == true
         calculator.assignable?(array, tuple1).should == false
       end
     end
 
     context 'when dealing with structs' do
       it 'should accept matching structs' do
         struct1 = struct_t({'a'=>Integer, 'b'=>Integer})
         struct2 = struct_t({'a'=>Integer, 'b'=>Integer})
         calculator.assignable?(struct1, struct2).should == true
         calculator.assignable?(struct2, struct1).should == true
       end
 
       it 'should accept matching structs where one is more general than the other' do
         struct1 = struct_t({'a'=>Integer, 'b'=>Integer})
         struct2 = struct_t({'a'=>Numeric, 'b'=>Numeric})
         calculator.assignable?(struct1, struct2).should == false
         calculator.assignable?(struct2, struct1).should == true
       end
 
       it 'should accept matching hash' do
         struct1 = struct_t({'a'=>Integer, 'b'=>Integer})
         non_empty_string = string_t()
         non_empty_string.size_type = range_t(1, nil)
         hsh = hash_t(non_empty_string, Integer)
         factory.constrain_size(hsh, 2, 2)
         calculator.assignable?(struct1, hsh).should == true
         calculator.assignable?(hsh, struct1).should == true
       end
     end
 
     it 'should recognize ruby type inheritance' do
       class Foo
       end
 
       class Bar < Foo
       end
 
       fooType = calculator.infer(Foo.new)
       barType = calculator.infer(Bar.new)
 
       calculator.assignable?(fooType, fooType).should == true
       calculator.assignable?(Foo, fooType).should == true
 
       calculator.assignable?(fooType, barType).should == true
       calculator.assignable?(Foo, barType).should == true
 
       calculator.assignable?(barType, fooType).should == false
       calculator.assignable?(Bar, fooType).should == false
     end
 
     it "should allow host class with same name" do
       hc1 = Puppet::Pops::Types::TypeFactory.host_class('the_name')
       hc2 = Puppet::Pops::Types::TypeFactory.host_class('the_name')
       calculator.assignable?(hc1, hc2).should == true
     end
 
     it "should allow host class with name assigned to hostclass without name" do
       hc1 = Puppet::Pops::Types::TypeFactory.host_class()
       hc2 = Puppet::Pops::Types::TypeFactory.host_class('the_name')
       calculator.assignable?(hc1, hc2).should == true
     end
 
     it "should reject host classes with different names" do
       hc1 = Puppet::Pops::Types::TypeFactory.host_class('the_name')
       hc2 = Puppet::Pops::Types::TypeFactory.host_class('another_name')
       calculator.assignable?(hc1, hc2).should == false
     end
 
     it "should reject host classes without name assigned to host class with name" do
       hc1 = Puppet::Pops::Types::TypeFactory.host_class('the_name')
       hc2 = Puppet::Pops::Types::TypeFactory.host_class()
       calculator.assignable?(hc1, hc2).should == false
     end
 
     it "should allow resource with same type_name and title" do
       r1 = Puppet::Pops::Types::TypeFactory.resource('file', 'foo')
       r2 = Puppet::Pops::Types::TypeFactory.resource('file', 'foo')
       calculator.assignable?(r1, r2).should == true
     end
 
     it "should allow more specific resource assignment" do
       r1 = Puppet::Pops::Types::TypeFactory.resource()
       r2 = Puppet::Pops::Types::TypeFactory.resource('file')
       calculator.assignable?(r1, r2).should == true
       r2 = Puppet::Pops::Types::TypeFactory.resource('file', '/tmp/foo')
       calculator.assignable?(r1, r2).should == true
       r1 = Puppet::Pops::Types::TypeFactory.resource('file')
       calculator.assignable?(r1, r2).should == true
     end
 
     it "should reject less specific resource assignment" do
       r1 = Puppet::Pops::Types::TypeFactory.resource('file', '/tmp/foo')
       r2 = Puppet::Pops::Types::TypeFactory.resource('file')
       calculator.assignable?(r1, r2).should == false
       r2 = Puppet::Pops::Types::TypeFactory.resource()
       calculator.assignable?(r1, r2).should == false
     end
 
   end
 
   context 'when testing if x is instance of type t' do
     include_context "types_setup"
 
     it 'should consider undef to be instance of Any, NilType, and optional' do
       calculator.instance?(Puppet::Pops::Types::PNilType.new(), nil).should    == true
       calculator.instance?(Puppet::Pops::Types::PAnyType.new(), nil).should == true
       calculator.instance?(Puppet::Pops::Types::POptionalType.new(), nil).should == true
     end
 
     it 'all types should be (ruby) instance of PAnyType' do
       all_types.each do |t|
         t.new.is_a?(Puppet::Pops::Types::PAnyType).should == true
       end
     end
 
     it "should consider :undef to be instance of Runtime['ruby', 'Symbol]" do
       calculator.instance?(Puppet::Pops::Types::PRuntimeType.new(:runtime => :ruby, :runtime_type_name => 'Symbol'), :undef).should == true
     end
 
     it "should consider :undef to be instance of an Optional type" do
       calculator.instance?(Puppet::Pops::Types::POptionalType.new(), :undef).should == true
     end
 
     it 'should not consider undef to be an instance of any other type than Any, NilType and Data' do
       types_to_test = all_types - [
         Puppet::Pops::Types::PAnyType,
         Puppet::Pops::Types::PNilType,
         Puppet::Pops::Types::PDataType,
         Puppet::Pops::Types::POptionalType,
         ]
 
       types_to_test.each {|t| calculator.instance?(t.new, nil).should == false }
       types_to_test.each {|t| calculator.instance?(t.new, :undef).should == false }
     end
 
     it 'should consider default to be instance of Default and Any' do
       calculator.instance?(Puppet::Pops::Types::PDefaultType.new(), :default).should == true
       calculator.instance?(Puppet::Pops::Types::PAnyType.new(), :default).should == true
     end
 
     it 'should not consider "default" to be an instance of anything but Default, and Any' do
       types_to_test = all_types - [
         Puppet::Pops::Types::PAnyType,
         Puppet::Pops::Types::PDefaultType,
         ]
 
       types_to_test.each {|t| calculator.instance?(t.new, :default).should == false }
     end
 
     it 'should consider fixnum instanceof PIntegerType' do
       calculator.instance?(Puppet::Pops::Types::PIntegerType.new(), 1).should == true
     end
 
     it 'should consider fixnum instanceof Fixnum' do
       calculator.instance?(Fixnum, 1).should == true
     end
 
     it 'should consider integer in range' do
       range = range_t(0,10)
       calculator.instance?(range, 1).should == true
       calculator.instance?(range, 10).should == true
       calculator.instance?(range, -1).should == false
       calculator.instance?(range, 11).should == false
     end
 
     it 'should consider string in length range' do
       range = factory.constrain_size(string_t, 1,3)
       calculator.instance?(range, 'a').should    == true
       calculator.instance?(range, 'abc').should  == true
       calculator.instance?(range, '').should     == false
       calculator.instance?(range, 'abcd').should == false
     end
 
     it 'should consider array in length range' do
       range = factory.constrain_size(array_t(integer_t), 1,3)
       calculator.instance?(range, [1]).should    == true
       calculator.instance?(range, [1,2,3]).should  == true
       calculator.instance?(range, []).should     == false
       calculator.instance?(range, [1,2,3,4]).should == false
     end
 
     it 'should consider hash in length range' do
       range = factory.constrain_size(hash_t(integer_t, integer_t), 1,2)
       calculator.instance?(range, {1=>1}).should             == true
       calculator.instance?(range, {1=>1, 2=>2}).should       == true
       calculator.instance?(range, {}).should                 == false
       calculator.instance?(range, {1=>1, 2=>2, 3=>3}).should == false
     end
 
     it 'should consider collection in length range for array ' do
       range = factory.constrain_size(collection_t, 1,3)
       calculator.instance?(range, [1]).should    == true
       calculator.instance?(range, [1,2,3]).should  == true
       calculator.instance?(range, []).should     == false
       calculator.instance?(range, [1,2,3,4]).should == false
     end
 
     it 'should consider collection in length range for hash' do
       range = factory.constrain_size(collection_t, 1,2)
       calculator.instance?(range, {1=>1}).should             == true
       calculator.instance?(range, {1=>1, 2=>2}).should       == true
       calculator.instance?(range, {}).should                 == false
       calculator.instance?(range, {1=>1, 2=>2, 3=>3}).should == false
     end
 
     it 'should consider string matching enum as instanceof' do
       enum = enum_t('XS', 'S', 'M', 'L', 'XL', '0')
       calculator.instance?(enum, 'XS').should  == true
       calculator.instance?(enum, 'S').should   == true
       calculator.instance?(enum, 'XXL').should == false
       calculator.instance?(enum, '').should    == false
       calculator.instance?(enum, '0').should   == true
       calculator.instance?(enum, 0).should     == false
     end
 
     it 'should consider array[string] as instance of Array[Enum] when strings are instance of Enum' do
       enum = enum_t('XS', 'S', 'M', 'L', 'XL', '0')
       array = array_t(enum)
       calculator.instance?(array, ['XS', 'S', 'XL']).should  == true
       calculator.instance?(array, ['XS', 'S', 'XXL']).should == false
     end
 
     it 'should consider array[mixed] as instance of Variant[mixed] when mixed types are listed in Variant' do
       enum = enum_t('XS', 'S', 'M', 'L', 'XL')
       sizes = range_t(30, 50)
       array = array_t(variant_t(enum, sizes))
       calculator.instance?(array, ['XS', 'S', 30, 50]).should  == true
       calculator.instance?(array, ['XS', 'S', 'XXL']).should   == false
       calculator.instance?(array, ['XS', 'S', 29]).should      == false
     end
 
     it 'should consider array[seq] as instance of Tuple[seq] when elements of seq are instance of' do
       tuple = tuple_t(Integer, String, Float)
       calculator.instance?(tuple, [1, 'a', 3.14]).should       == true
       calculator.instance?(tuple, [1.2, 'a', 3.14]).should     == false
       calculator.instance?(tuple, [1, 1, 3.14]).should         == false
       calculator.instance?(tuple, [1, 'a', 1]).should          == false
     end
 
     it 'should consider hash[cont] as instance of Struct[cont-t]' do
       struct = struct_t({'a'=>Integer, 'b'=>String, 'c'=>Float})
       calculator.instance?(struct, {'a'=>1, 'b'=>'a', 'c'=>3.14}).should       == true
       calculator.instance?(struct, {'a'=>1.2, 'b'=>'a', 'c'=>3.14}).should     == false
       calculator.instance?(struct, {'a'=>1, 'b'=>1, 'c'=>3.14}).should         == false
       calculator.instance?(struct, {'a'=>1, 'b'=>'a', 'c'=>1}).should          == false
     end
 
     context 'and t is Data' do
       it 'undef should be considered instance of Data' do
         calculator.instance?(data_t, nil).should == true
       end
 
       it 'other symbols should not be considered instance of Data' do
         calculator.instance?(data_t, :love).should == false
       end
 
       it 'an empty array should be considered instance of Data' do
         calculator.instance?(data_t, []).should == true
       end
 
       it 'an empty hash should be considered instance of Data' do
         calculator.instance?(data_t, {}).should == true
       end
 
       it 'a hash with nil/undef data should be considered instance of Data' do
         calculator.instance?(data_t, {'a' => nil}).should == true
       end
 
       it 'a hash with nil/default key should not considered instance of Data' do
         calculator.instance?(data_t, {nil => 10}).should == false
         calculator.instance?(data_t, {:default => 10}).should == false
       end
 
       it 'an array with nil entries should be considered instance of Data' do
         calculator.instance?(data_t, [nil]).should == true
       end
 
       it 'an array with nil + data entries should be considered instance of Data' do
         calculator.instance?(data_t, [1, nil, 'a']).should == true
       end
     end
 
     context "and t is something Callable" do
 
       it 'a Closure should be considered a Callable' do
         factory = Puppet::Pops::Model::Factory
         params = [factory.PARAM('a')]
         the_block = factory.LAMBDA(params,factory.literal(42))
         the_closure = Puppet::Pops::Evaluator::Closure.new(:fake_evaluator, the_block, :fake_scope)
         expect(calculator.instance?(all_callables_t, the_closure)).to be_true
         expect(calculator.instance?(callable_t(object_t), the_closure)).to be_true
         expect(calculator.instance?(callable_t(object_t, object_t), the_closure)).to be_false
       end
 
       it 'a Function instance should be considered a Callable' do
         fc = Puppet::Functions.create_function(:foo) do
           dispatch :foo do
-            param 'String', 'a'
+            param 'String', :a
           end
 
           def foo(a)
             a
           end
         end
         f = fc.new(:closure_scope, :loader)
         # Any callable
         expect(calculator.instance?(all_callables_t, f)).to be_true
         # Callable[String]
         expect(calculator.instance?(callable_t(String), f)).to be_true
       end
     end
   end
 
   context 'when converting a ruby class' do
     it 'should yield \'PIntegerType\' for Integer, Fixnum, and Bignum' do
       [Integer,Fixnum,Bignum].each do |c|
         calculator.type(c).class.should == Puppet::Pops::Types::PIntegerType
       end
     end
 
     it 'should yield \'PFloatType\' for Float' do
       calculator.type(Float).class.should == Puppet::Pops::Types::PFloatType
     end
 
     it 'should yield \'PBooleanType\' for FalseClass and TrueClass' do
       [FalseClass,TrueClass].each do |c|
         calculator.type(c).class.should == Puppet::Pops::Types::PBooleanType
       end
     end
 
     it 'should yield \'PNilType\' for NilClass' do
       calculator.type(NilClass).class.should == Puppet::Pops::Types::PNilType
     end
 
     it 'should yield \'PStringType\' for String' do
       calculator.type(String).class.should == Puppet::Pops::Types::PStringType
     end
 
     it 'should yield \'PRegexpType\' for Regexp' do
       calculator.type(Regexp).class.should == Puppet::Pops::Types::PRegexpType
     end
 
     it 'should yield \'PArrayType[PDataType]\' for Array' do
       t = calculator.type(Array)
       t.class.should == Puppet::Pops::Types::PArrayType
       t.element_type.class.should == Puppet::Pops::Types::PDataType
     end
 
     it 'should yield \'PHashType[PScalarType,PDataType]\' for Hash' do
       t = calculator.type(Hash)
       t.class.should == Puppet::Pops::Types::PHashType
       t.key_type.class.should == Puppet::Pops::Types::PScalarType
       t.element_type.class.should == Puppet::Pops::Types::PDataType
     end
   end
 
   context 'when representing the type as string' do
     it 'should yield \'Type\' for PType' do
       calculator.string(Puppet::Pops::Types::PType.new()).should == 'Type'
     end
 
     it 'should yield \'Object\' for PAnyType' do
       calculator.string(Puppet::Pops::Types::PAnyType.new()).should == 'Any'
     end
 
     it 'should yield \'Scalar\' for PScalarType' do
       calculator.string(Puppet::Pops::Types::PScalarType.new()).should == 'Scalar'
     end
 
     it 'should yield \'Boolean\' for PBooleanType' do
       calculator.string(Puppet::Pops::Types::PBooleanType.new()).should == 'Boolean'
     end
 
     it 'should yield \'Data\' for PDataType' do
       calculator.string(Puppet::Pops::Types::PDataType.new()).should == 'Data'
     end
 
     it 'should yield \'Numeric\' for PNumericType' do
       calculator.string(Puppet::Pops::Types::PNumericType.new()).should == 'Numeric'
     end
 
     it 'should yield \'Integer\' and from/to for PIntegerType' do
       int_T = Puppet::Pops::Types::PIntegerType
       calculator.string(int_T.new()).should == 'Integer'
       int = int_T.new()
       int.from = 1
       int.to = 1
       calculator.string(int).should == 'Integer[1, 1]'
       int = int_T.new()
       int.from = 1
       int.to = 2
       calculator.string(int).should == 'Integer[1, 2]'
       int = int_T.new()
       int.from = nil
       int.to = 2
       calculator.string(int).should == 'Integer[default, 2]'
       int = int_T.new()
       int.from = 2
       int.to = nil
       calculator.string(int).should == 'Integer[2, default]'
     end
 
     it 'should yield \'Float\' for PFloatType' do
       calculator.string(Puppet::Pops::Types::PFloatType.new()).should == 'Float'
     end
 
     it 'should yield \'Regexp\' for PRegexpType' do
       calculator.string(Puppet::Pops::Types::PRegexpType.new()).should == 'Regexp'
     end
 
     it 'should yield \'Regexp[/pat/]\' for parameterized PRegexpType' do
       t = Puppet::Pops::Types::PRegexpType.new()
       t.pattern = ('a/b')
       calculator.string(Puppet::Pops::Types::PRegexpType.new()).should == 'Regexp'
     end
 
     it 'should yield \'String\' for PStringType' do
       calculator.string(Puppet::Pops::Types::PStringType.new()).should == 'String'
     end
 
     it 'should yield \'String\' for PStringType with multiple values' do
       calculator.string(string_t('a', 'b', 'c')).should == 'String'
     end
 
     it 'should yield \'String\' and from/to for PStringType' do
       string_T = Puppet::Pops::Types::PStringType
       calculator.string(factory.constrain_size(string_T.new(), 1,1)).should == 'String[1, 1]'
       calculator.string(factory.constrain_size(string_T.new(), 1,2)).should == 'String[1, 2]'
       calculator.string(factory.constrain_size(string_T.new(), :default, 2)).should == 'String[default, 2]'
       calculator.string(factory.constrain_size(string_T.new(), 2, :default)).should == 'String[2, default]'
     end
 
     it 'should yield \'Array[Integer]\' for PArrayType[PIntegerType]' do
       t = Puppet::Pops::Types::PArrayType.new()
       t.element_type = Puppet::Pops::Types::PIntegerType.new()
       calculator.string(t).should == 'Array[Integer]'
     end
 
     it 'should yield \'Collection\' and from/to for PCollectionType' do
       col = collection_t()
       calculator.string(factory.constrain_size(col.copy, 1,1)).should == 'Collection[1, 1]'
       calculator.string(factory.constrain_size(col.copy, 1,2)).should == 'Collection[1, 2]'
       calculator.string(factory.constrain_size(col.copy, :default, 2)).should == 'Collection[default, 2]'
       calculator.string(factory.constrain_size(col.copy, 2, :default)).should == 'Collection[2, default]'
     end
 
     it 'should yield \'Array\' and from/to for PArrayType' do
       arr = array_t(string_t)
       calculator.string(factory.constrain_size(arr.copy, 1,1)).should == 'Array[String, 1, 1]'
       calculator.string(factory.constrain_size(arr.copy, 1,2)).should == 'Array[String, 1, 2]'
       calculator.string(factory.constrain_size(arr.copy, :default, 2)).should == 'Array[String, default, 2]'
       calculator.string(factory.constrain_size(arr.copy, 2, :default)).should == 'Array[String, 2, default]'
     end
 
     it 'should yield \'Tuple[Integer]\' for PTupleType[PIntegerType]' do
       t = Puppet::Pops::Types::PTupleType.new()
       t.addTypes(Puppet::Pops::Types::PIntegerType.new())
       calculator.string(t).should == 'Tuple[Integer]'
     end
 
     it 'should yield \'Tuple[T, T,..]\' for PTupleType[T, T, ...]' do
       t = Puppet::Pops::Types::PTupleType.new()
       t.addTypes(Puppet::Pops::Types::PIntegerType.new())
       t.addTypes(Puppet::Pops::Types::PIntegerType.new())
       t.addTypes(Puppet::Pops::Types::PStringType.new())
       calculator.string(t).should == 'Tuple[Integer, Integer, String]'
     end
 
     it 'should yield \'Tuple\' and from/to for PTupleType' do
       tuple_t = tuple_t(string_t)
       calculator.string(factory.constrain_size(tuple_t.copy, 1,1)).should == 'Tuple[String, 1, 1]'
       calculator.string(factory.constrain_size(tuple_t.copy, 1,2)).should == 'Tuple[String, 1, 2]'
       calculator.string(factory.constrain_size(tuple_t.copy, :default, 2)).should == 'Tuple[String, default, 2]'
       calculator.string(factory.constrain_size(tuple_t.copy, 2, :default)).should == 'Tuple[String, 2, default]'
     end
 
     it 'should yield \'Struct\' and details for PStructType' do
       struct_t = struct_t({'a'=>Integer, 'b'=>String})
       calculator.string(struct_t).should == "Struct[{'a'=>Integer, 'b'=>String}]"
       struct_t = struct_t({})
       calculator.string(struct_t).should == "Struct"
     end
 
     it 'should yield \'Hash[String, Integer]\' for PHashType[PStringType, PIntegerType]' do
       t = Puppet::Pops::Types::PHashType.new()
       t.key_type = Puppet::Pops::Types::PStringType.new()
       t.element_type = Puppet::Pops::Types::PIntegerType.new()
       calculator.string(t).should == 'Hash[String, Integer]'
     end
 
     it 'should yield \'Hash\' and from/to for PHashType' do
       hsh = hash_t(string_t, string_t)
       calculator.string(factory.constrain_size(hsh.copy, 1,1)).should == 'Hash[String, String, 1, 1]'
       calculator.string(factory.constrain_size(hsh.copy, 1,2)).should == 'Hash[String, String, 1, 2]'
       calculator.string(factory.constrain_size(hsh.copy, :default, 2)).should == 'Hash[String, String, default, 2]'
       calculator.string(factory.constrain_size(hsh.copy, 2, :default)).should == 'Hash[String, String, 2, default]'
     end
 
     it "should yield 'Class' for a PHostClassType" do
       t = Puppet::Pops::Types::PHostClassType.new()
       calculator.string(t).should == 'Class'
     end
 
     it "should yield 'Class[x]' for a PHostClassType[x]" do
       t = Puppet::Pops::Types::PHostClassType.new()
       t.class_name = 'x'
       calculator.string(t).should == 'Class[x]'
     end
 
     it "should yield 'Resource' for a PResourceType" do
       t = Puppet::Pops::Types::PResourceType.new()
       calculator.string(t).should == 'Resource'
     end
 
     it 'should yield \'File\' for a PResourceType[\'File\']' do
       t = Puppet::Pops::Types::PResourceType.new()
       t.type_name = 'File'
       calculator.string(t).should == 'File'
     end
 
     it "should yield 'File['/tmp/foo']' for a PResourceType['File', '/tmp/foo']" do
       t = Puppet::Pops::Types::PResourceType.new()
       t.type_name = 'File'
       t.title = '/tmp/foo'
       calculator.string(t).should == "File['/tmp/foo']"
     end
 
     it "should yield 'Enum[s,...]' for a PEnumType[s,...]" do
       t = enum_t('a', 'b', 'c')
       calculator.string(t).should == "Enum['a', 'b', 'c']"
     end
 
     it "should yield 'Pattern[/pat/,...]' for a PPatternType['pat',...]" do
       t = pattern_t('a')
       t2 = pattern_t('a', 'b', 'c')
       calculator.string(t).should == "Pattern[/a/]"
       calculator.string(t2).should == "Pattern[/a/, /b/, /c/]"
     end
 
     it "should escape special characters in the string for a PPatternType['pat',...]" do
       t = pattern_t('a/b')
       calculator.string(t).should == "Pattern[/a\\/b/]"
     end
 
     it "should yield 'Variant[t1,t2,...]' for a PVariantType[t1, t2,...]" do
       t1 = string_t()
       t2 = integer_t()
       t3 = pattern_t('a')
       t = variant_t(t1, t2, t3)
       calculator.string(t).should == "Variant[String, Integer, Pattern[/a/]]"
     end
 
     it "should yield 'Callable' for generic callable" do
       expect(calculator.string(all_callables_t)).to eql("Callable")
     end
 
     it "should yield 'Callable[0,0]' for callable without params" do
       expect(calculator.string(callable_t)).to eql("Callable[0, 0]")
     end
 
     it "should yield 'Callable[t,t]' for callable with typed parameters" do
       expect(calculator.string(callable_t(String, Integer))).to eql("Callable[String, Integer]")
     end
 
     it "should yield 'Callable[t,min,max]' for callable with size constraint (infinite max)" do
       expect(calculator.string(callable_t(String, 0))).to eql("Callable[String, 0, default]")
     end
 
     it "should yield 'Callable[t,min,max]' for callable with size constraint (capped max)" do
       expect(calculator.string(callable_t(String, 0, 3))).to eql("Callable[String, 0, 3]")
     end
 
     it "should yield 'Callable[min,max]' callable with size > 0" do
       expect(calculator.string(callable_t(0, 0))).to eql("Callable[0, 0]")
       expect(calculator.string(callable_t(0, 1))).to eql("Callable[0, 1]")
       expect(calculator.string(callable_t(0, :default))).to eql("Callable[0, default]")
     end
 
     it "should yield 'Callable[Callable]' for callable with block" do
       expect(calculator.string(callable_t(all_callables_t))).to eql("Callable[0, 0, Callable]")
       expect(calculator.string(callable_t(string_t, all_callables_t))).to eql("Callable[String, Callable]")
       expect(calculator.string(callable_t(string_t, 1,1, all_callables_t))).to eql("Callable[String, 1, 1, Callable]")
     end
 
     it "should yield Unit for a Unit type" do
       expect(calculator.string(unit_t)).to eql('Unit')
     end
   end
 
   context 'when processing meta type' do
     it 'should infer PType as the type of all other types' do
       ptype = Puppet::Pops::Types::PType
       calculator.infer(Puppet::Pops::Types::PNilType.new()       ).is_a?(ptype).should() == true
       calculator.infer(Puppet::Pops::Types::PDataType.new()      ).is_a?(ptype).should() == true
       calculator.infer(Puppet::Pops::Types::PScalarType.new()   ).is_a?(ptype).should() == true
       calculator.infer(Puppet::Pops::Types::PStringType.new()    ).is_a?(ptype).should() == true
       calculator.infer(Puppet::Pops::Types::PNumericType.new()   ).is_a?(ptype).should() == true
       calculator.infer(Puppet::Pops::Types::PIntegerType.new()   ).is_a?(ptype).should() == true
       calculator.infer(Puppet::Pops::Types::PFloatType.new()     ).is_a?(ptype).should() == true
       calculator.infer(Puppet::Pops::Types::PRegexpType.new()   ).is_a?(ptype).should() == true
       calculator.infer(Puppet::Pops::Types::PBooleanType.new()   ).is_a?(ptype).should() == true
       calculator.infer(Puppet::Pops::Types::PCollectionType.new()).is_a?(ptype).should() == true
       calculator.infer(Puppet::Pops::Types::PArrayType.new()     ).is_a?(ptype).should() == true
       calculator.infer(Puppet::Pops::Types::PHashType.new()      ).is_a?(ptype).should() == true
       calculator.infer(Puppet::Pops::Types::PRuntimeType.new()   ).is_a?(ptype).should() == true
       calculator.infer(Puppet::Pops::Types::PHostClassType.new() ).is_a?(ptype).should() == true
       calculator.infer(Puppet::Pops::Types::PResourceType.new()  ).is_a?(ptype).should() == true
       calculator.infer(Puppet::Pops::Types::PEnumType.new()      ).is_a?(ptype).should() == true
       calculator.infer(Puppet::Pops::Types::PPatternType.new()   ).is_a?(ptype).should() == true
       calculator.infer(Puppet::Pops::Types::PVariantType.new()   ).is_a?(ptype).should() == true
       calculator.infer(Puppet::Pops::Types::PTupleType.new()     ).is_a?(ptype).should() == true
       calculator.infer(Puppet::Pops::Types::POptionalType.new()  ).is_a?(ptype).should() == true
       calculator.infer(Puppet::Pops::Types::PCallableType.new()  ).is_a?(ptype).should() == true
     end
 
     it 'should infer PType as the type of all other types' do
       ptype = Puppet::Pops::Types::PType
       calculator.string(calculator.infer(Puppet::Pops::Types::PNilType.new()       )).should == "Type[Undef]"
       calculator.string(calculator.infer(Puppet::Pops::Types::PDataType.new()      )).should == "Type[Data]"
       calculator.string(calculator.infer(Puppet::Pops::Types::PScalarType.new()   )).should == "Type[Scalar]"
       calculator.string(calculator.infer(Puppet::Pops::Types::PStringType.new()    )).should == "Type[String]"
       calculator.string(calculator.infer(Puppet::Pops::Types::PNumericType.new()   )).should == "Type[Numeric]"
       calculator.string(calculator.infer(Puppet::Pops::Types::PIntegerType.new()   )).should == "Type[Integer]"
       calculator.string(calculator.infer(Puppet::Pops::Types::PFloatType.new()     )).should == "Type[Float]"
       calculator.string(calculator.infer(Puppet::Pops::Types::PRegexpType.new()    )).should == "Type[Regexp]"
       calculator.string(calculator.infer(Puppet::Pops::Types::PBooleanType.new()   )).should == "Type[Boolean]"
       calculator.string(calculator.infer(Puppet::Pops::Types::PCollectionType.new())).should == "Type[Collection]"
       calculator.string(calculator.infer(Puppet::Pops::Types::PArrayType.new()     )).should == "Type[Array[?]]"
       calculator.string(calculator.infer(Puppet::Pops::Types::PHashType.new()      )).should == "Type[Hash[?, ?]]"
       calculator.string(calculator.infer(Puppet::Pops::Types::PRuntimeType.new()   )).should == "Type[Runtime[?, ?]]"
       calculator.string(calculator.infer(Puppet::Pops::Types::PHostClassType.new() )).should == "Type[Class]"
       calculator.string(calculator.infer(Puppet::Pops::Types::PResourceType.new()  )).should == "Type[Resource]"
       calculator.string(calculator.infer(Puppet::Pops::Types::PEnumType.new()      )).should == "Type[Enum]"
       calculator.string(calculator.infer(Puppet::Pops::Types::PVariantType.new()   )).should == "Type[Variant]"
       calculator.string(calculator.infer(Puppet::Pops::Types::PPatternType.new()   )).should == "Type[Pattern]"
       calculator.string(calculator.infer(Puppet::Pops::Types::PTupleType.new()     )).should == "Type[Tuple]"
       calculator.string(calculator.infer(Puppet::Pops::Types::POptionalType.new()  )).should == "Type[Optional]"
       calculator.string(calculator.infer(Puppet::Pops::Types::PCallableType.new()  )).should == "Type[Callable]"
 
       calculator.infer(Puppet::Pops::Types::PResourceType.new(:type_name => 'foo::fee::fum')).to_s.should == "Type[Foo::Fee::Fum]"
       calculator.string(calculator.infer(Puppet::Pops::Types::PResourceType.new(:type_name => 'foo::fee::fum'))).should == "Type[Foo::Fee::Fum]"
       calculator.infer(Puppet::Pops::Types::PResourceType.new(:type_name => 'Foo::Fee::Fum')).to_s.should == "Type[Foo::Fee::Fum]"
     end
 
     it "computes the common type of PType's type parameter" do
       int_t    = Puppet::Pops::Types::PIntegerType.new()
       string_t = Puppet::Pops::Types::PStringType.new()
       calculator.string(calculator.infer([int_t])).should == "Array[Type[Integer], 1, 1]"
       calculator.string(calculator.infer([int_t, string_t])).should == "Array[Type[Scalar], 2, 2]"
     end
 
     it 'should infer PType as the type of ruby classes' do
       class Foo
       end
       [Object, Numeric, Integer, Fixnum, Bignum, Float, String, Regexp, Array, Hash, Foo].each do |c|
         calculator.infer(c).is_a?(Puppet::Pops::Types::PType).should() == true
       end
     end
 
     it 'should infer PType as the type of PType (meta regression short-circuit)' do
       calculator.infer(Puppet::Pops::Types::PType.new()).is_a?(Puppet::Pops::Types::PType).should() == true
     end
 
     it 'computes instance? to be true if parameterized and type match' do
       int_t    = Puppet::Pops::Types::PIntegerType.new()
       type_t   = Puppet::Pops::Types::TypeFactory.type_type(int_t)
       type_type_t   = Puppet::Pops::Types::TypeFactory.type_type(type_t)
       calculator.instance?(type_type_t, type_t).should == true
     end
 
     it 'computes instance? to be false if parameterized and type do not match' do
       int_t    = Puppet::Pops::Types::PIntegerType.new()
       string_t = Puppet::Pops::Types::PStringType.new()
       type_t   = Puppet::Pops::Types::TypeFactory.type_type(int_t)
       type_t2   = Puppet::Pops::Types::TypeFactory.type_type(string_t)
       type_type_t   = Puppet::Pops::Types::TypeFactory.type_type(type_t)
       # i.e. Type[Integer] =~ Type[Type[Integer]] # false
       calculator.instance?(type_type_t, type_t2).should == false
     end
 
     it 'computes instance? to be true if unparameterized and matched against a type[?]' do
       int_t    = Puppet::Pops::Types::PIntegerType.new()
       type_t   = Puppet::Pops::Types::TypeFactory.type_type(int_t)
       calculator.instance?(Puppet::Pops::Types::PType.new, type_t).should == true
     end
   end
 
   context "when asking for an enumerable " do
     it "should produce an enumerable for an Integer range that is not infinite" do
       t = Puppet::Pops::Types::PIntegerType.new()
       t.from = 1
       t.to = 10
       calculator.enumerable(t).respond_to?(:each).should == true
     end
 
     it "should not produce an enumerable for an Integer range that has an infinite side" do
       t = Puppet::Pops::Types::PIntegerType.new()
       t.from = nil
       t.to = 10
       calculator.enumerable(t).should == nil
 
       t = Puppet::Pops::Types::PIntegerType.new()
       t.from = 1
       t.to = nil
       calculator.enumerable(t).should == nil
     end
 
     it "all but Integer range are not enumerable" do
       [Object, Numeric, Float, String, Regexp, Array, Hash].each do |t|
         calculator.enumerable(calculator.type(t)).should == nil
       end
     end
   end
 
   context "when dealing with different types of inference" do
     it "an instance specific inference is produced by infer" do
       calculator.infer(['a','b']).element_type.values.should == ['a', 'b']
     end
 
     it "a generic inference is produced using infer_generic" do
       calculator.infer_generic(['a','b']).element_type.values.should == []
     end
 
     it "a generic result is created by generalize! given an instance specific result for an Array" do
       generic = calculator.infer(['a','b'])
       generic.element_type.values.should == ['a', 'b']
       calculator.generalize!(generic)
       generic.element_type.values.should == []
     end
 
     it "a generic result is created by generalize! given an instance specific result for a Hash" do
       generic = calculator.infer({'a' =>1,'b' => 2})
       generic.key_type.values.sort.should == ['a', 'b']
       generic.element_type.from.should == 1
       generic.element_type.to.should == 2
       calculator.generalize!(generic)
       generic.key_type.values.should == []
       generic.element_type.from.should == nil
       generic.element_type.to.should == nil
     end
 
     it "does not reduce by combining types when using infer_set" do
       element_type = calculator.infer(['a','b',1,2]).element_type
       element_type.class.should == Puppet::Pops::Types::PScalarType
       inferred_type = calculator.infer_set(['a','b',1,2])
       inferred_type.class.should == Puppet::Pops::Types::PTupleType
       element_types = inferred_type.types
       element_types[0].class.should == Puppet::Pops::Types::PStringType
       element_types[1].class.should == Puppet::Pops::Types::PStringType
       element_types[2].class.should == Puppet::Pops::Types::PIntegerType
       element_types[3].class.should == Puppet::Pops::Types::PIntegerType
     end
 
     it "does not reduce by combining types when using infer_set and values are undef" do
       element_type = calculator.infer(['a',nil]).element_type
       element_type.class.should == Puppet::Pops::Types::PStringType
       inferred_type = calculator.infer_set(['a',nil])
       inferred_type.class.should == Puppet::Pops::Types::PTupleType
       element_types = inferred_type.types
       element_types[0].class.should == Puppet::Pops::Types::PStringType
       element_types[1].class.should == Puppet::Pops::Types::PNilType
     end
   end
 
   context 'when determening callability' do
     context 'and given is exact' do
       it 'with callable' do
         required = callable_t(string_t)
         given = callable_t(string_t)
         calculator.callable?(required, given).should == true
       end
 
       it 'with args tuple' do
         required = callable_t(string_t)
         given = tuple_t(string_t)
         calculator.callable?(required, given).should == true
       end
 
       it 'with args tuple having a block' do
         required = callable_t(string_t, callable_t(string_t))
         given = tuple_t(string_t, callable_t(string_t))
         calculator.callable?(required, given).should == true
       end
 
       it 'with args array' do
         required = callable_t(string_t)
         given = array_t(string_t)
         factory.constrain_size(given, 1, 1)
         calculator.callable?(required, given).should == true
       end
     end
 
     context 'and given is more generic' do
       it 'with callable' do
         required = callable_t(string_t)
         given = callable_t(object_t)
         calculator.callable?(required, given).should == true
       end
 
       it 'with args tuple' do
         required = callable_t(string_t)
         given = tuple_t(object_t)
         calculator.callable?(required, given).should == false
       end
 
       it 'with args tuple having a block' do
         required = callable_t(string_t, callable_t(string_t))
         given = tuple_t(string_t, callable_t(object_t))
         calculator.callable?(required, given).should == true
       end
 
       it 'with args tuple having a block with captures rest' do
         required = callable_t(string_t, callable_t(string_t))
         given = tuple_t(string_t, callable_t(object_t, 0, :default))
         calculator.callable?(required, given).should == true
       end
     end
 
     context 'and given is more specific' do
       it 'with callable' do
         required = callable_t(object_t)
         given = callable_t(string_t)
         calculator.callable?(required, given).should == false
       end
 
       it 'with args tuple' do
         required = callable_t(object_t)
         given = tuple_t(string_t)
         calculator.callable?(required, given).should == true
       end
 
       it 'with args tuple having a block' do
         required = callable_t(string_t, callable_t(object_t))
         given = tuple_t(string_t, callable_t(string_t))
         calculator.callable?(required, given).should == false
       end
 
       it 'with args tuple having a block with captures rest' do
         required = callable_t(string_t, callable_t(object_t))
         given = tuple_t(string_t, callable_t(string_t, 0, :default))
         calculator.callable?(required, given).should == false
       end
     end
   end
 
   matcher :be_assignable_to do |type|
     calc = Puppet::Pops::Types::TypeCalculator.new
 
     match do |actual|
       calc.assignable?(type, actual)
     end
 
     failure_message_for_should do |actual|
       "#{calc.string(actual)} should be assignable to #{calc.string(type)}"
     end
 
     failure_message_for_should_not do |actual|
       "#{calc.string(actual)} is assignable to #{calc.string(type)} when it should not"
     end
   end
 
 end