diff --git a/lib/puppet/pops/evaluator/access_operator.rb b/lib/puppet/pops/evaluator/access_operator.rb
index e054ac115..c05b2b2b2 100644
--- a/lib/puppet/pops/evaluator/access_operator.rb
+++ b/lib/puppet/pops/evaluator/access_operator.rb
@@ -1,593 +1,588 @@
 # AccessOperator handles operator []
 # This operator is part of evaluation.
 #
 class Puppet::Pops::Evaluator::AccessOperator
   # Provides access to the Puppet 3.x runtime (scope, etc.)
   # This separation has been made to make it easier to later migrate the evaluator to an improved runtime.
   #
   include Puppet::Pops::Evaluator::Runtime3Support
 
   Issues = Puppet::Pops::Issues
   TYPEFACTORY = Puppet::Pops::Types::TypeFactory
   EMPTY_STRING = ''.freeze
 
   attr_reader :semantic
 
   # Initialize with AccessExpression to enable reporting issues
   # @param access_expression [Puppet::Pops::Model::AccessExpression] the semantic object being evaluated
   # @return [void]
   #
   def initialize(access_expression)
     @@access_visitor ||= Puppet::Pops::Visitor.new(self, "access", 2, nil)
     @semantic = access_expression
   end
 
   def access (o, scope, *keys)
     @@access_visitor.visit_this_2(self, o, scope, keys)
   end
 
   protected
 
   def access_Object(o, scope, keys)
     fail(Issues::OPERATOR_NOT_APPLICABLE, @semantic.left_expr, :operator=>'[]', :left_value => o)
   end
 
   def access_String(o, scope, keys)
     keys.flatten!
     result = case keys.size
     when 0
       fail(Puppet::Pops::Issues::BAD_STRING_SLICE_ARITY, @semantic.left_expr, {:actual => keys.size})
     when 1
       # Note that Ruby 1.8.7 requires a length of 1 to produce a String
       k1 = coerce_numeric(keys[0], @semantic.keys, scope)
       bad_access_key_type(o, 0, k1, Integer) unless k1.is_a?(Integer)
       k2 = 1
       k1 = k1 < 0 ? o.length + k1 : k1           # abs pos
       # if k1 is outside, a length of 1 always produces an empty string
       if k1 < 0
         EMPTY_STRING
       else
         o[ k1, k2 ]
       end
     when 2
       k1 = coerce_numeric(keys[0], @semantic.keys, scope)
       k2 = coerce_numeric(keys[1], @semantic.keys, scope)
       [k1, k2].each_with_index { |k,i| bad_access_key_type(o, i, k, Integer) unless k.is_a?(Integer) }
 
       k1 = k1 < 0 ? o.length + k1 : k1           # abs pos (negative is count from end)
       k2 = k2 < 0 ? o.length - k1 + k2 + 1 : k2  # abs length (negative k2 is length from pos to end count)
       # if k1 is outside, adjust to first position, and adjust length
       if k1 < 0
         k2 = k2 + k1
         k1 = 0
       end
       o[ k1, k2 ]
     else
       fail(Puppet::Pops::Issues::BAD_STRING_SLICE_ARITY, @semantic.left_expr, {:actual => keys.size})
     end
     # Specified as: an index outside of range, or empty result == empty string
     (result.nil? || result.empty?) ? EMPTY_STRING : result
   end
 
   # Parameterizes a PRegexp Type with a pattern string or r ruby egexp
   #
   def access_PRegexpType(o, scope, keys)
     keys.flatten!
     unless keys.size == 1
       blamed = keys.size == 0 ? @semantic : @semantic.keys[1]
       fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, blamed, :base_type => o, :min=>1, :actual => keys.size)
     end
     assert_keys(keys, o, 1, 1, String, Regexp)
     Puppet::Pops::Types::TypeFactory.regexp(*keys)
   end
 
   # Evaluates <ary>[] with 1 or 2 arguments. One argument is an index lookup, two arguments is a slice from/to.
   #
   def access_Array(o, scope, keys)
     keys.flatten!
     case keys.size
     when 0
       fail(Puppet::Pops::Issues::BAD_ARRAY_SLICE_ARITY, @semantic.left_expr, {:actual => keys.size})
     when 1
       k = coerce_numeric(keys[0], @semantic.keys[0], scope)
       unless k.is_a?(Integer)
         bad_access_key_type(o, 0, k, Integer)
       end
       o[k]
     when 2
       # A slice [from, to] with support for -1 to mean start, or end respectively.
       k1 = coerce_numeric(keys[0], @semantic.keys[0], scope)
       k2 = coerce_numeric(keys[1], @semantic.keys[1], scope)
 
       [k1, k2].each_with_index { |k,i| bad_access_key_type(o, i, k, Integer) unless k.is_a?(Integer) }
 
       # Help confused Ruby do the right thing (it truncates to the right, but negative index + length can never overlap
       # the available range.
       k1 = k1 < 0 ? o.length + k1 : k1           # abs pos (negative is count from end)
       k2 = k2 < 0 ? o.length - k1 + k2 + 1 : k2  # abs length (negative k2 is length from pos to end count)
       # if k1 is outside, adjust to first position, and adjust length
       if k1 < 0
         k2 = k2 + k1
         k1 = 0
       end
       # Help ruby always return empty array when asking for a sub array
       result = o[ k1, k2 ]
       result.nil? ? [] : result
     else
       fail(Puppet::Pops::Issues::BAD_ARRAY_SLICE_ARITY, @semantic.left_expr, {:actual => keys.size})
     end
   end
 
 
   # Evaluates <hsh>[] with support for one or more arguments. If more than one argument is used, the result
   # is an array with each lookup.
   # @note
   #   Does not flatten its keys to enable looking up with a structure
   #
   def access_Hash(o, scope, keys)
     # Look up key in hash, if key is nil, try alternate form (:undef) before giving up.
     # This is done because the hash may have been produced by 3x logic and may thus contain :undef.
     result = keys.collect do |k|
       o.fetch(k) { |key| key.nil? ? o[:undef] : nil }
     end
     case result.size
     when 0
       fail(Puppet::Pops::Issues::BAD_HASH_SLICE_ARITY, @semantic.left_expr, {:actual => keys.size})
     when 1
       result.pop
     else
       # remove nil elements and return
       result.compact!
       result
     end
   end
 
   def access_PEnumType(o, scope, keys)
     keys.flatten!
     assert_keys(keys, o, 1, Float::INFINITY, String)
     Puppet::Pops::Types::TypeFactory.enum(*keys)
   end
 
   def access_PVariantType(o, scope, keys)
     keys.flatten!
     assert_keys(keys, o, 1, Float::INFINITY, Puppet::Pops::Types::PAnyType)
     Puppet::Pops::Types::TypeFactory.variant(*keys)
   end
 
   def access_PTupleType(o, scope, keys)
     keys.flatten!
     if TYPEFACTORY.is_range_parameter?(keys[-2]) && TYPEFACTORY.is_range_parameter?(keys[-1])
       size_type = TYPEFACTORY.range(keys[-2], keys[-1])
       keys = keys[0, keys.size - 2]
     elsif TYPEFACTORY.is_range_parameter?(keys[-1])
       size_type = TYPEFACTORY.range(keys[-1], :default)
       keys = keys[0, keys.size - 1]
     end
     assert_keys(keys, o, 1, Float::INFINITY, Puppet::Pops::Types::PAnyType)
     t = Puppet::Pops::Types::TypeFactory.tuple(*keys)
     # set size type, or nil for default (exactly 1)
     t.size_type = size_type
     t
   end
 
   def access_PCallableType(o, scope, keys)
     TYPEFACTORY.callable(*keys)
   end
 
   def access_PStructType(o, scope, keys)
     assert_keys(keys, o, 1, 1, Hash)
     TYPEFACTORY.struct(keys[0])
   end
 
   def access_PStringType(o, scope, keys)
     keys.flatten!
     case keys.size
     when 1
       size_t = collection_size_t(0, keys[0])
     when 2
       size_t = collection_size_t(0, keys[0], keys[1])
     else
       fail(Puppet::Pops::Issues::BAD_STRING_SLICE_ARITY, @semantic, {:actual => keys.size})
     end
     string_t = Puppet::Pops::Types::TypeFactory.string()
     string_t.size_type = size_t
     string_t
   end
 
   # Asserts type of each key and calls fail with BAD_TYPE_SPECIFICATION
   # @param keys [Array<Object>] the evaluated keys
   # @param o [Object] evaluated LHS reported as :base_type
   # @param min [Integer] the minimum number of keys (typically 1)
   # @param max [Numeric] the maximum number of keys (use same as min, specific number, or Float::INFINITY)
   # @param allowed_classes [Class] a variable number of classes that each key must be an instance of (any)
   # @api private
   #
   def assert_keys(keys, o, min, max, *allowed_classes)
     size = keys.size
     unless size.between?(min, max || Float::INFINITY)
       fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, @semantic, :base_type => o, :min=>1, :max => max, :actual => keys.size)
     end
     keys.each_with_index do |k, i|
       unless allowed_classes.any? {|clazz| k.is_a?(clazz) }
         bad_type_specialization_key_type(o, i, k, *allowed_classes)
       end
     end
   end
 
   def bad_access_key_type(lhs, key_index, actual, *expected_classes)
     fail(Puppet::Pops::Issues::BAD_SLICE_KEY_TYPE, @semantic.keys[key_index], {
       :left_value => lhs,
       :actual => bad_key_type_name(actual),
       :expected_classes => expected_classes
     })
   end
 
   def bad_key_type_name(actual)
     case actual
     when nil
       'Undef'
     when :default
       'Default'
     else
       Puppet::Pops::Types::TypeCalculator.generalize!(Puppet::Pops::Types::TypeCalculator.infer(actual)).to_s
     end
   end
 
   def bad_type_specialization_key_type(type, key_index, actual, *expected_classes)
     label_provider = Puppet::Pops::Model::ModelLabelProvider.new()
     expected = expected_classes.map {|c| label_provider.label(c) }.join(' or ')
     fail(Puppet::Pops::Issues::BAD_TYPE_SPECIALIZATION, @semantic.keys[key_index], {
       :type => type,
       :message => "Cannot use #{bad_key_type_name(actual)} where #{expected} is expected"
     })
   end
 
   def access_PPatternType(o, scope, keys)
     keys.flatten!
     assert_keys(keys, o, 1, Float::INFINITY, String, Regexp, Puppet::Pops::Types::PPatternType, Puppet::Pops::Types::PRegexpType)
     Puppet::Pops::Types::TypeFactory.pattern(*keys)
   end
 
   def access_POptionalType(o, scope, keys)
     keys.flatten!
     if keys.size == 1
       unless keys[0].is_a?(Puppet::Pops::Types::PAnyType)
         fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Optional-Type', :actual => keys[0].class})
       end
       result = Puppet::Pops::Types::POptionalType.new()
       result.optional_type = keys[0]
       result
     else
       fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, @semantic, {:base_type => 'Optional-Type', :min => 1, :actual => keys.size})
     end
   end
 
   def access_PType(o, scope, keys)
     keys.flatten!
     if keys.size == 1
       unless keys[0].is_a?(Puppet::Pops::Types::PAnyType)
         fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Type-Type', :actual => keys[0].class})
       end
       result = Puppet::Pops::Types::PType.new()
       result.type = keys[0]
       result
     else
       fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, @semantic, {:base_type => 'Type-Type', :min => 1, :actual => keys.size})
     end
   end
 
   def access_PRuntimeType(o, scope, keys)
     keys.flatten!
     assert_keys(keys, o, 2, 2, String, String)
     # create runtime type based on runtime and name of class, (not inference of key's type)
     Puppet::Pops::Types::TypeFactory.runtime(*keys)
   end
 
   def access_PIntegerType(o, scope, keys)
     keys.flatten!
     unless keys.size.between?(1, 2)
       fail(Puppet::Pops::Issues::BAD_INTEGER_SLICE_ARITY, @semantic, {:actual => keys.size})
     end
     keys.each_with_index do |x, index|
       fail(Puppet::Pops::Issues::BAD_INTEGER_SLICE_TYPE, @semantic.keys[index],
         {:actual => x.class}) unless (x.is_a?(Integer) || x == :default)
     end
     ranged_integer = Puppet::Pops::Types::PIntegerType.new()
     from, to = keys
     ranged_integer.from = from == :default ? nil : from
     ranged_integer.to = to == :default ? nil : to
     ranged_integer
   end
 
   def access_PFloatType(o, scope, keys)
     keys.flatten!
     unless keys.size.between?(1, 2)
       fail(Puppet::Pops::Issues::BAD_FLOAT_SLICE_ARITY, @semantic, {:actual => keys.size})
     end
     keys.each_with_index do |x, index|
       fail(Puppet::Pops::Issues::BAD_FLOAT_SLICE_TYPE, @semantic.keys[index],
         {:actual => x.class}) unless (x.is_a?(Float) || x.is_a?(Integer) || x == :default)
     end
     ranged_float = Puppet::Pops::Types::PFloatType.new()
     from, to = keys
     ranged_float.from = from == :default || from.nil? ? nil : Float(from)
     ranged_float.to = to == :default || to.nil? ? nil : Float(to)
     ranged_float
   end
 
   # A Hash can create a new Hash type, one arg sets value type, two args sets key and value type in new type.
   # With 3 or 4 arguments, these are used to create a size constraint.
   # It is not possible to create a collection of Hash types directly.
   #
   def access_PHashType(o, scope, keys)
     keys.flatten!
     keys[0,2].each_with_index do |k, index|
       unless k.is_a?(Puppet::Pops::Types::PAnyType)
         fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[index], {:base_type => 'Hash-Type', :actual => k.class})
       end
     end
     case keys.size
-    when 1
-      result = Puppet::Pops::Types::PHashType.new()
-      result.key_type = o.key_type.copy
-      result.element_type = keys[0]
-      result
     when 2
       result = Puppet::Pops::Types::PHashType.new()
       result.key_type = keys[0]
       result.element_type = keys[1]
       result
     when 3
       result = Puppet::Pops::Types::PHashType.new()
       result.key_type = keys[0]
       result.element_type = keys[1]
       size_t = collection_size_t(1, keys[2])
       result
     when 4
       result = Puppet::Pops::Types::PHashType.new()
       result.key_type = keys[0]
       result.element_type = keys[1]
       size_t = collection_size_t(1, keys[2], keys[3])
       result
     else
       fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, @semantic, {
-        :base_type => 'Hash-Type', :min => 1, :max => 4, :actual => keys.size
+        :base_type => 'Hash-Type', :min => 2, :max => 4, :actual => keys.size
       })
     end
     result.size_type = size_t if size_t
     result
   end
 
   # CollectionType is parameterized with a range
   def access_PCollectionType(o, scope, keys)
     keys.flatten!
     case keys.size
     when 1
       size_t = collection_size_t(1, keys[0])
     when 2
       size_t = collection_size_t(1, keys[0], keys[1])
     else
       fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, @semantic,
         {:base_type => 'Collection-Type', :min => 1, :max => 2, :actual => keys.size})
     end
     result = Puppet::Pops::Types::PCollectionType.new()
     result.size_type = size_t
     result
   end
 
   # An Array can create a new Array type. It is not possible to create a collection of Array types.
   #
   def access_PArrayType(o, scope, keys)
     keys.flatten!
     case keys.size
     when 1
       size_t = nil
     when 2
       size_t = collection_size_t(1, keys[1])
     when 3
       size_t = collection_size_t(1, keys[1], keys[2])
     else
       fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, @semantic,
         {:base_type => 'Array-Type', :min => 1, :max => 3, :actual => keys.size})
     end
     unless keys[0].is_a?(Puppet::Pops::Types::PAnyType)
       fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Array-Type', :actual => keys[0].class})
     end
     result = Puppet::Pops::Types::PArrayType.new()
     result.element_type = keys[0]
     result.size_type = size_t
     result
   end
 
   # Produces an PIntegerType (range) given one or two keys.
   def collection_size_t(start_index, *keys)
     if keys.size == 1 && keys[0].is_a?(Puppet::Pops::Types::PIntegerType)
       keys[0].copy
     else
       keys.each_with_index do |x, index|
         fail(Puppet::Pops::Issues::BAD_COLLECTION_SLICE_TYPE, @semantic.keys[start_index + index],
           {:actual => x.class}) unless (x.is_a?(Integer) || x == :default)
       end
       ranged_integer = Puppet::Pops::Types::PIntegerType.new()
       from, to = keys
       ranged_integer.from = from == :default ? nil : from
       ranged_integer.to = to == :default ? nil : to
       ranged_integer
     end
   end
 
   # A Puppet::Resource represents either just a type (no title), or is a fully qualified type/title.
   #
   def access_Resource(o, scope, keys)
     # To access a Puppet::Resource as if it was a PResourceType, simply infer it, and take the type of
     # the parameterized meta type (i.e. Type[Resource[the_resource_type, the_resource_title]])
     t = Puppet::Pops::Types::TypeCalculator.infer(o).type
     # must map "undefined title" from resource to nil
     t.title = nil if t.title == EMPTY_STRING
     access(t, scope, *keys)
   end
 
   # A Resource can create a new more specific Resource type, and/or an array of resource types
   # If the given type has title set, it can not be specified further.
   # @example
   #   Resource[File]               # => File
   #   Resource[File, 'foo']        # => File[foo]
   #   Resource[File. 'foo', 'bar'] # => [File[foo], File[bar]]
   #   File['foo', 'bar']           # => [File[foo], File[bar]]
   #   File['foo']['bar']           # => Value of the 'bar' parameter in the File['foo'] resource
   #   Resource[File]['foo', 'bar'] # => [File[Foo], File[bar]]
   #   Resource[File, 'foo', 'bar'] # => [File[foo], File[bar]]
   #   Resource[File, 'foo']['bar'] # => Value of the 'bar' parameter in the File['foo'] resource
   #
   def access_PResourceType(o, scope, keys)
     blamed = keys.size == 0 ? @semantic : @semantic.keys[0]
 
     if keys.size == 0
       fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, blamed,
         :base_type => Puppet::Pops::Types::TypeCalculator.new().string(o), :min => 1, :max => -1, :actual => 0)
     end
 
     # Must know which concrete resource type to operate on in all cases.
     # It is not allowed to specify the type in an array arg - e.g. Resource[[File, 'foo']]
     # type_name is LHS type_name if set, else the first given arg
     type_name = o.type_name || keys.shift
     type_name = case type_name
     when Puppet::Pops::Types::PResourceType
       type_name.type_name
     when String
       type_name.downcase
     else
       # blame given left expression if it defined the type, else the first given key expression
       blame = o.type_name.nil? ? @semantic.keys[0] : @semantic.left_expr
       fail(Puppet::Pops::Issues::ILLEGAL_RESOURCE_SPECIALIZATION, blame, {:actual => bad_key_type_name(type_name)})
     end
 
     # type name must conform
     if type_name !~ Puppet::Pops::Patterns::CLASSREF
       fail(Puppet::Pops::Issues::ILLEGAL_CLASSREF, blamed, {:name=>type_name})
     end
 
     # The result is an array if multiple titles are given, or if titles are specified with an array
     # (possibly multiple arrays, and nested arrays).
     result_type_array = keys.size > 1 || keys[0].is_a?(Array)
     keys_orig_size = keys.size
 
     keys.flatten!
     keys.compact!
 
     # If given keys  that were just a mix of empty/nil with empty array as a result.
     # As opposed to calling the function the wrong way (without any arguments), (configurable issue),
     # Return an empty array
     #
     if keys.empty? && keys_orig_size > 0
       optionally_fail(Puppet::Pops::Issues::EMPTY_RESOURCE_SPECIALIZATION, blamed)
       return result_type_array ? [] : nil
     end
 
     if !o.title.nil?
       # lookup resource and return one or more parameter values
       resource = find_resource(scope, o.type_name, o.title)
       unless resource
         fail(Puppet::Pops::Issues::UNKNOWN_RESOURCE, @semantic, {:type_name => o.type_name, :title => o.title})
       end
 
       result = keys.map do |k|
         unless is_parameter_of_resource?(scope, resource, k)
           fail(Puppet::Pops::Issues::UNKNOWN_RESOURCE_PARAMETER, @semantic,
             {:type_name => o.type_name, :title => o.title, :param_name=>k})
         end
         get_resource_parameter_value(scope, resource, k)
       end
       return result_type_array ? result : result.pop
     end
 
 
     keys = [:no_title] if keys.size < 1 # if there was only a type_name and it was consumed
     result = keys.each_with_index.map do |t, i|
       unless t.is_a?(String) || t == :no_title
         index = keys_orig_size != keys.size ? i+1 : i
         fail(Puppet::Pops::Issues::BAD_TYPE_SPECIALIZATION, @semantic.keys[index], {
           :type => o,
           :message => "Cannot use #{bad_key_type_name(t)} where a resource title String is expected"
         })
       end
 
       rtype = Puppet::Pops::Types::PResourceType.new()
       rtype.type_name = type_name
       rtype.title = (t == :no_title ? nil : t)
       rtype
     end
     # returns single type if request was for a single entity, else an array of types (possibly empty)
     return result_type_array ? result : result.pop
   end
 
   def access_PHostClassType(o, scope, keys)
     blamed = keys.size == 0 ? @semantic : @semantic.keys[0]
     keys_orig_size = keys.size
 
     if keys_orig_size == 0
       fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, blamed,
         :base_type => Puppet::Pops::Types::TypeCalculator.new().string(o), :min => 1, :max => -1, :actual => 0)
     end
 
     # The result is an array if multiple classnames are given, or if classnames are specified with an array
     # (possibly multiple arrays, and nested arrays).
     result_type_array = keys.size > 1 || keys[0].is_a?(Array)
 
     keys.flatten!
     keys.compact!
 
     # If given keys  that were just a mix of empty/nil with empty array as a result.
     # As opposed to calling the function the wrong way (without any arguments), (configurable issue),
     # Return an empty array
     #
     if keys.empty? && keys_orig_size > 0
       optionally_fail(Puppet::Pops::Issues::EMPTY_RESOURCE_SPECIALIZATION, blamed)
       return result_type_array ? [] : nil
     end
 
     if o.class_name.nil?
       # The type argument may be a Resource Type - the Puppet Language allows a reference such as
       # Class[Foo], and this is interpreted as Class[Resource[Foo]] - which is ok as long as the resource
       # does not have a title. This should probably be deprecated.
       #
       result = keys.each_with_index.map do |c, i|
         name = if c.is_a?(Puppet::Pops::Types::PResourceType) && !c.type_name.nil? && c.title.nil?
                  # type_name is already downcase. Don't waste time trying to downcase again
                  c.type_name
                elsif c.is_a?(String)
                  c.downcase
                else
                  fail(Puppet::Pops::Issues::ILLEGAL_HOSTCLASS_NAME, @semantic.keys[i], {:name => c})
                end
 
         if name =~ Puppet::Pops::Patterns::NAME
           ctype = Puppet::Pops::Types::PHostClassType.new()
           # Remove leading '::' since all references are global, and 3x runtime does the wrong thing
           ctype.class_name = name.sub(/^::/, EMPTY_STRING)
           ctype
         else
           fail(Issues::ILLEGAL_NAME, @semantic.keys[i], {:name=>c})
         end
       end
     else
       # lookup class resource and return one or more parameter values
       resource = find_resource(scope, 'class', o.class_name)
       if resource
         result = keys.map do |k|
           if is_parameter_of_resource?(scope, resource, k)
             get_resource_parameter_value(scope, resource, k)
           else
             fail(Puppet::Pops::Issues::UNKNOWN_RESOURCE_PARAMETER, @semantic,
               {:type_name => 'Class', :title => o.class_name, :param_name=>k})
           end
         end
       else
         fail(Puppet::Pops::Issues::UNKNOWN_RESOURCE, @semantic, {:type_name => 'Class', :title => o.class_name})
       end
     end
 
     # returns single type as type, else an array of types
     return result_type_array ? result : result.pop
   end
 end
diff --git a/lib/puppet/pops/types/type_parser.rb b/lib/puppet/pops/types/type_parser.rb
index 1b65e147e..4c0abdae4 100644
--- a/lib/puppet/pops/types/type_parser.rb
+++ b/lib/puppet/pops/types/type_parser.rb
@@ -1,475 +1,472 @@
 # This class provides parsing of Type Specification from a string into the Type
 # Model that is produced by the Puppet::Pops::Types::TypeFactory.
 #
 # The Type Specifications that are parsed are the same as the stringified forms
 # of types produced by the {Puppet::Pops::Types::TypeCalculator TypeCalculator}.
 #
 # @api public
 class Puppet::Pops::Types::TypeParser
   # @api private
   TYPES = Puppet::Pops::Types::TypeFactory
 
   # @api public
   def initialize
     @parser = Puppet::Pops::Parser::Parser.new()
     @type_transformer = Puppet::Pops::Visitor.new(nil, "interpret", 0, 0)
   end
 
   # Produces a *puppet type* based on the given string.
   #
   # @example
   #     parser.parse('Integer')
   #     parser.parse('Array[String]')
   #     parser.parse('Hash[Integer, Array[String]]')
   #
   # @param string [String] a string with the type expressed in stringified form as produced by the 
   #   {Puppet::Pops::Types::TypeCalculator#string TypeCalculator#string} method.
   # @return [Puppet::Pops::Types::PAnyType] a specialization of the PAnyType representing the type.
   #
   # @api public
   #
   def parse(string)
     # TODO: This state (@string) can be removed since the parse result of newer future parser
     # contains a Locator in its SourcePosAdapter and the Locator keeps the string.
     # This way, there is no difference between a parsed "string" and something that has been parsed
     # earlier and fed to 'interpret'
     #
     @string = string
     model = @parser.parse_string(@string)
     if model
       interpret(model.current)
     else
       raise_invalid_type_specification_error
     end
   end
 
   # @api private
   def interpret(ast)
     result = @type_transformer.visit_this_0(self, ast)
     result = result.body if result.is_a?(Puppet::Pops::Model::Program)
     raise_invalid_type_specification_error unless result.is_a?(Puppet::Pops::Types::PAnyType)
     result
   end
 
   # @api private
   def interpret_any(ast)
     @type_transformer.visit_this_0(self, ast)
   end
 
   # @api private
   def interpret_Object(o)
     raise_invalid_type_specification_error
   end
 
   # @api private
   def interpret_Program(o)
     interpret(o.body)
   end
 
   # @api private
   def interpret_QualifiedName(o)
     o.value
   end
 
   # @api private
   def interpret_LiteralString(o)
     o.value
   end
 
   def interpret_LiteralRegularExpression(o)
     o.value
   end
 
   # @api private
   def interpret_String(o)
     o
   end
 
   # @api private
   def interpret_LiteralDefault(o)
     :default
   end
 
   # @api private
   def interpret_LiteralInteger(o)
     o.value
   end
 
   # @api private
   def interpret_LiteralFloat(o)
     o.value
   end
 
   # @api private
   def interpret_LiteralHash(o)
     result = {}
     o.entries.each do |entry|
       result[@type_transformer.visit_this_0(self, entry.key)] = @type_transformer.visit_this_0(self, entry.value)
     end
     result
   end
 
   # @api private
   def interpret_QualifiedReference(name_ast)
     case name_ast.value
     when "integer"
       TYPES.integer
 
     when "float"
       TYPES.float
 
     when "numeric"
         TYPES.numeric
 
     when "string"
       TYPES.string
 
     when "enum"
       TYPES.enum
 
     when "boolean"
       TYPES.boolean
 
     when "pattern"
       TYPES.pattern
 
     when "regexp"
       TYPES.regexp
 
     when "data"
       TYPES.data
 
     when "array"
       TYPES.array_of_data
 
     when "hash"
       TYPES.hash_of_data
 
     when "class"
       TYPES.host_class()
 
     when "resource"
       TYPES.resource()
 
     when "collection"
       TYPES.collection()
 
     when "scalar"
       TYPES.scalar()
 
     when "catalogentry"
       TYPES.catalog_entry()
 
     when "undef"
       TYPES.undef()
 
     when "default"
       TYPES.default()
 
     when "any"
       TYPES.any()
 
     when "variant"
       TYPES.variant()
 
     when "optional"
       TYPES.optional()
 
     when "runtime"
       TYPES.runtime()
 
     when "type"
       TYPES.type_type()
 
     when "tuple"
       TYPES.tuple()
 
     when "struct"
       TYPES.struct()
 
     when "callable"
       # A generic callable as opposed to one that does not accept arguments
       TYPES.all_callables()
 
     else
       TYPES.resource(name_ast.value)
     end
   end
 
   # @api private
   def interpret_AccessExpression(parameterized_ast)
     parameters = parameterized_ast.keys.collect { |param| interpret_any(param) }
 
     unless parameterized_ast.left_expr.is_a?(Puppet::Pops::Model::QualifiedReference)
       raise_invalid_type_specification_error
     end
 
     case parameterized_ast.left_expr.value
     when "array"
       case parameters.size
       when 1
       when 2
         size_type =
         if parameters[1].is_a?(Puppet::Pops::Types::PIntegerType)
           parameters[1].copy
         else
           assert_range_parameter(parameters[1])
           TYPES.range(parameters[1], :default)
         end
       when 3
         assert_range_parameter(parameters[1])
         assert_range_parameter(parameters[2])
         size_type = TYPES.range(parameters[1], parameters[2])
       else
         raise_invalid_parameters_error("Array", "1 to 3", parameters.size)
       end
       assert_type(parameters[0])
       t = TYPES.array_of(parameters[0])
       t.size_type = size_type if size_type
       t
 
     when "hash"
       result = case parameters.size
-      when 1
-        assert_type(parameters[0])
-        TYPES.hash_of(parameters[0])
       when 2
         assert_type(parameters[0])
         assert_type(parameters[1])
         TYPES.hash_of(parameters[1], parameters[0])
       when 3
         size_type =
         if parameters[2].is_a?(Puppet::Pops::Types::PIntegerType)
           parameters[2].copy
         else
           assert_range_parameter(parameters[2])
           TYPES.range(parameters[2], :default)
         end
         assert_type(parameters[0])
         assert_type(parameters[1])
         TYPES.hash_of(parameters[1], parameters[0])
       when 4
         assert_range_parameter(parameters[2])
         assert_range_parameter(parameters[3])
         size_type = TYPES.range(parameters[2], parameters[3])
         assert_type(parameters[0])
         assert_type(parameters[1])
         TYPES.hash_of(parameters[1], parameters[0])
       else
-        raise_invalid_parameters_error("Hash", "1 to 4", parameters.size)
+        raise_invalid_parameters_error("Hash", "2 to 4", parameters.size)
       end
       result.size_type = size_type if size_type
       result
 
     when "collection"
       size_type = case parameters.size
       when 1
         if parameters[0].is_a?(Puppet::Pops::Types::PIntegerType)
           parameters[0].copy
         else
           assert_range_parameter(parameters[0])
           TYPES.range(parameters[0], :default)
         end
       when 2
         assert_range_parameter(parameters[0])
         assert_range_parameter(parameters[1])
         TYPES.range(parameters[0], parameters[1])
       else
         raise_invalid_parameters_error("Collection", "1 to 2", parameters.size)
       end
       result = TYPES.collection
       result.size_type = size_type
       result
 
     when "class"
       if parameters.size != 1
         raise_invalid_parameters_error("Class", 1, parameters.size)
       end
       TYPES.host_class(parameters[0])
 
     when "resource"
       if parameters.size == 1
         TYPES.resource(parameters[0])
       elsif parameters.size != 2
         raise_invalid_parameters_error("Resource", "1 or 2", parameters.size)
       else
         TYPES.resource(parameters[0], parameters[1])
       end
 
     when "regexp"
       # 1 parameter being a string, or regular expression
       raise_invalid_parameters_error("Regexp", "1", parameters.size) unless parameters.size == 1
       TYPES.regexp(parameters[0])
 
     when "enum"
       # 1..m parameters being strings
       raise_invalid_parameters_error("Enum", "1 or more", parameters.size) unless parameters.size >= 1
       TYPES.enum(*parameters)
 
     when "pattern"
       # 1..m parameters being strings or regular expressions
       raise_invalid_parameters_error("Pattern", "1 or more", parameters.size) unless parameters.size >= 1
       TYPES.pattern(*parameters)
 
     when "variant"
       # 1..m parameters being strings or regular expressions
       raise_invalid_parameters_error("Variant", "1 or more", parameters.size) unless parameters.size >= 1
       TYPES.variant(*parameters)
 
     when "tuple"
       # 1..m parameters being types (last two optionally integer or literal default
       raise_invalid_parameters_error("Tuple", "1 or more", parameters.size) unless parameters.size >= 1
       length = parameters.size
       if TYPES.is_range_parameter?(parameters[-2])
         # min, max specification
         min = parameters[-2]
         min = (min == :default || min == 'default') ? 0 : min
         assert_range_parameter(parameters[-1])
         max = parameters[-1]
         max = max == :default ? nil : max
         parameters = parameters[0, length-2]
       elsif TYPES.is_range_parameter?(parameters[-1])
         min = parameters[-1]
         min = (min == :default || min == 'default') ? 0 : min
         max = nil
         parameters = parameters[0, length-1]
       end
       t = TYPES.tuple(*parameters)
       if min || max
         TYPES.constrain_size(t, min, max)
       end
       t
 
     when "callable"
       # 1..m parameters being types (last three optionally integer or literal default, and a callable)
       TYPES.callable(*parameters)
 
     when "struct"
       # 1..m parameters being types (last two optionally integer or literal default
       raise_invalid_parameters_error("Struct", "1", parameters.size) unless parameters.size == 1
       assert_struct_parameter(parameters[0])
       TYPES.struct(parameters[0])
 
     when "integer"
       if parameters.size == 1
         case parameters[0]
         when Integer
           TYPES.range(parameters[0], parameters[0])
         when :default
           TYPES.integer # unbound
         end
       elsif parameters.size != 2
         raise_invalid_parameters_error("Integer", "1 or 2", parameters.size)
      else
        TYPES.range(parameters[0] == :default ? nil : parameters[0], parameters[1] == :default ? nil : parameters[1])
      end
 
     when "float"
       if parameters.size == 1
         case parameters[0]
         when Integer, Float
           TYPES.float_range(parameters[0], parameters[0])
         when :default
           TYPES.float # unbound
         end
       elsif parameters.size != 2
         raise_invalid_parameters_error("Float", "1 or 2", parameters.size)
      else
        TYPES.float_range(parameters[0] == :default ? nil : parameters[0], parameters[1] == :default ? nil : parameters[1])
      end
 
     when "string"
       size_type =
       case parameters.size
       when 1
         if parameters[0].is_a?(Puppet::Pops::Types::PIntegerType)
           parameters[0].copy
         else
           assert_range_parameter(parameters[0])
           TYPES.range(parameters[0], :default)
         end
       when 2
         assert_range_parameter(parameters[0])
         assert_range_parameter(parameters[1])
         TYPES.range(parameters[0], parameters[1])
       else
         raise_invalid_parameters_error("String", "1 to 2", parameters.size)
       end
       result = TYPES.string
       result.size_type = size_type
       result
 
     when "optional"
       if parameters.size != 1
         raise_invalid_parameters_error("Optional", 1, parameters.size)
       end
       assert_type(parameters[0])
       TYPES.optional(parameters[0])
 
     when "any", "data", "catalogentry", "boolean", "scalar", "undef", "numeric", "default"
       raise_unparameterized_type_error(parameterized_ast.left_expr)
 
     when "type"
       if parameters.size != 1
         raise_invalid_parameters_error("Type", 1, parameters.size)
       end
       assert_type(parameters[0])
       TYPES.type_type(parameters[0])
 
     when "runtime"
       raise_invalid_parameters_error("Runtime", "2", parameters.size) unless parameters.size == 2
       TYPES.runtime(*parameters)
 
     else
       # It is a resource such a File['/tmp/foo']
       type_name = parameterized_ast.left_expr.value
       if parameters.size != 1
         raise_invalid_parameters_error(type_name.capitalize, 1, parameters.size)
       end
       TYPES.resource(type_name, parameters[0])
     end
   end
 
   private
 
   def assert_type(t)
     raise_invalid_type_specification_error unless t.is_a?(Puppet::Pops::Types::PAnyType)
     true
   end
 
   def assert_range_parameter(t)
     raise_invalid_type_specification_error unless TYPES.is_range_parameter?(t)
   end
 
   def assert_struct_parameter(h)
     raise_invalid_type_specification_error unless h.is_a?(Hash)
     h.each do |k,v|
       # TODO: Should have stricter name rule
       raise_invalid_type_specification_error unless k.is_a?(String) && !k.empty?
       assert_type(v)
     end
   end
 
   def raise_invalid_type_specification_error
     raise Puppet::ParseError,
       "The expression <#{@string}> is not a valid type specification."
   end
 
   def raise_invalid_parameters_error(type, required, given)
     raise Puppet::ParseError,
       "Invalid number of type parameters specified: #{type} requires #{required}, #{given} provided"
   end
 
   def raise_unparameterized_type_error(ast)
     raise Puppet::ParseError, "Not a parameterized type <#{original_text_of(ast)}>"
   end
 
   def raise_unknown_type_error(ast)
     raise Puppet::ParseError, "Unknown type <#{original_text_of(ast)}>"
   end
 
   def original_text_of(ast)
     position = Puppet::Pops::Adapters::SourcePosAdapter.adapt(ast)
     position.extract_text()
   end
 end
diff --git a/spec/unit/pops/evaluator/access_ops_spec.rb b/spec/unit/pops/evaluator/access_ops_spec.rb
index 0fa4779a0..8eb696d47 100644
--- a/spec/unit/pops/evaluator/access_ops_spec.rb
+++ b/spec/unit/pops/evaluator/access_ops_spec.rb
@@ -1,441 +1,441 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/pops'
 require 'puppet/pops/evaluator/evaluator_impl'
 require 'puppet/pops/types/type_factory'
 
 
 # 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/AccessOperator' do
   include EvaluatorRspecHelper
 
   def range(from, to)
     Puppet::Pops::Types::TypeFactory.range(from, to)
   end
 
   def float_range(from, to)
     Puppet::Pops::Types::TypeFactory.float_range(from, to)
   end
 
   context 'The evaluator when operating on a String' do
     it 'can get a single character using a single key index to []' do
       expect(evaluate(literal('abc')[1])).to eql('b')
     end
 
     it 'can get the last character using the key -1 in []' do
       expect(evaluate(literal('abc')[-1])).to eql('c')
     end
 
     it 'can get a substring by giving two keys' do
       expect(evaluate(literal('abcd')[1,2])).to eql('bc')
       # flattens keys
       expect(evaluate(literal('abcd')[[1,2]])).to eql('bc')
     end
 
     it 'produces empty string for a substring out of range' do
       expect(evaluate(literal('abc')[100])).to eql('')
     end
 
     it 'raises an error if arity is wrong for []' do
       expect{evaluate(literal('abc')[])}.to raise_error(/String supports \[\] with one or two arguments\. Got 0/)
       expect{evaluate(literal('abc')[1,2,3])}.to raise_error(/String supports \[\] with one or two arguments\. Got 3/)
     end
   end
 
   context 'The evaluator when operating on an Array' do
     it 'is tested with the correct assumptions' do
       expect(literal([1,2,3])[1].current.is_a?(Puppet::Pops::Model::AccessExpression)).to eql(true)
     end
 
     it 'can get an element using a single key index to []' do
       expect(evaluate(literal([1,2,3])[1])).to eql(2)
     end
 
     it 'can get the last element using the key -1 in []' do
       expect(evaluate(literal([1,2,3])[-1])).to eql(3)
     end
 
     it 'can get a slice of elements using two keys' do
       expect(evaluate(literal([1,2,3,4])[1,2])).to eql([2,3])
       # flattens keys
       expect(evaluate(literal([1,2,3,4])[[1,2]])).to eql([2,3])
     end
 
     it 'produces nil for a missing entry' do
       expect(evaluate(literal([1,2,3])[100])).to eql(nil)
     end
 
     it 'raises an error if arity is wrong for []' do
       expect{evaluate(literal([1,2,3,4])[])}.to raise_error(/Array supports \[\] with one or two arguments\. Got 0/)
       expect{evaluate(literal([1,2,3,4])[1,2,3])}.to raise_error(/Array supports \[\] with one or two arguments\. Got 3/)
     end
   end
 
   context 'The evaluator when operating on a Hash' do
     it 'can get a single element giving a single key to []' do
       expect(evaluate(literal({'a'=>1,'b'=>2,'c'=>3})['b'])).to eql(2)
     end
 
     it 'can lookup an array' do
       expect(evaluate(literal({[1]=>10,[2]=>20})[[2]])).to eql(20)
     end
 
     it 'produces nil for a missing key' do
       expect(evaluate(literal({'a'=>1,'b'=>2,'c'=>3})['x'])).to eql(nil)
     end
 
     it 'can get multiple elements by giving multiple keys to []' do
       expect(evaluate(literal({'a'=>1,'b'=>2,'c'=>3, 'd'=>4})['b', 'd'])).to eql([2, 4])
     end
 
     it 'compacts the result when using multiple keys' do
       expect(evaluate(literal({'a'=>1,'b'=>2,'c'=>3, 'd'=>4})['b', 'x'])).to eql([2])
     end
 
     it 'produces an empty array if none of multiple given keys were missing' do
       expect(evaluate(literal({'a'=>1,'b'=>2,'c'=>3, 'd'=>4})['x', 'y'])).to eql([])
     end
 
     it 'raises an error if arity is wrong for []' do
       expect{evaluate(literal({'a'=>1,'b'=>2,'c'=>3})[])}.to raise_error(/Hash supports \[\] with one or more arguments\. Got 0/)
     end
   end
 
   context "When applied to a type it" do
     let(:types) { Puppet::Pops::Types::TypeFactory }
 
     # Integer
     #
     it 'produces an Integer[from, to]' do
       expr = fqr('Integer')[1, 3]
       expect(evaluate(expr)).to eql(range(1,3))
 
       # arguments are flattened
       expr = fqr('Integer')[[1, 3]]
       expect(evaluate(expr)).to eql(range(1,3))
     end
 
     it 'produces an Integer[1]' do
       expr = fqr('Integer')[1]
       expect(evaluate(expr)).to eql(range(1,1))
     end
 
     it 'produces an Integer[from, <from]' do
       expr = fqr('Integer')[1,0]
       expect(evaluate(expr)).to eql(range(1,0))
     end
 
     it 'produces an error for Integer[] if there are more than 2 keys' do
       expr = fqr('Integer')[1,2,3]
       expect { evaluate(expr)}.to raise_error(/with one or two arguments/)
     end
 
     # Float
     #
     it 'produces a Float[from, to]' do
       expr = fqr('Float')[1, 3]
       expect(evaluate(expr)).to eql(float_range(1.0,3.0))
 
       # arguments are flattened
       expr = fqr('Float')[[1, 3]]
       expect(evaluate(expr)).to eql(float_range(1.0,3.0))
     end
 
     it 'produces a Float[1.0]' do
       expr = fqr('Float')[1.0]
       expect(evaluate(expr)).to eql(float_range(1.0,1.0))
     end
 
     it 'produces a Float[1]' do
       expr = fqr('Float')[1]
       expect(evaluate(expr)).to eql(float_range(1.0,1.0))
     end
 
     it 'produces a Float[from, <from]' do
       expr = fqr('Float')[1.0,0.0]
       expect(evaluate(expr)).to eql(float_range(1.0,0.0))
     end
 
     it 'produces an error for Float[] if there are more than 2 keys' do
       expr = fqr('Float')[1,2,3]
       expect { evaluate(expr)}.to raise_error(/with one or two arguments/)
     end
 
     # Hash Type
     #
-    it 'produces a Hash[Scalar,String] from the expression Hash[String]' do
-      expr = fqr('Hash')[fqr('String')]
+    it 'produces a Hash[Scalar,String] from the expression Hash[Scalar, String]' do
+      expr = fqr('Hash')[fqr('Scalar'), fqr('String')]
       expect(evaluate(expr)).to be_the_type(types.hash_of(types.string, types.scalar))
 
       # arguments are flattened
-      expr = fqr('Hash')[[fqr('String')]]
+      expr = fqr('Hash')[[fqr('Scalar'), fqr('String')]]
       expect(evaluate(expr)).to be_the_type(types.hash_of(types.string, types.scalar))
     end
 
-    it 'produces a Hash[String,String] from the expression Hash[String, String]' do
-      expr = fqr('Hash')[fqr('String'), fqr('String')]
-      expect(evaluate(expr)).to be_the_type(types.hash_of(types.string, types.string))
+    it 'gives an error if only one type is specified ' do
+      expr = fqr('Hash')[fqr('String')]
+      expect {evaluate(expr)}.to raise_error(/accepts 2 to 4 arguments/)
     end
 
-    it 'produces a Hash[Scalar,String] from the expression Hash[Integer][String]' do
-      expr = fqr('Hash')[fqr('Integer')][fqr('String')]
-      expect(evaluate(expr)).to be_the_type(types.hash_of(types.string, types.scalar))
+    it 'produces a Hash[Scalar,String] from the expression Hash[Integer, Array][Integer, String]' do
+      expr = fqr('Hash')[fqr('Integer'), fqr('Array')][fqr('Integer'), fqr('String')]
+      expect(evaluate(expr)).to be_the_type(types.hash_of(types.string, types.integer))
     end
 
     it "gives an error if parameter is not a type" do
       expr = fqr('Hash')['String']
       expect { evaluate(expr)}.to raise_error(/Hash-Type\[\] arguments must be types/)
     end
 
     # Array Type
     #
     it 'produces an Array[String] from the expression Array[String]' do
       expr = fqr('Array')[fqr('String')]
       expect(evaluate(expr)).to be_the_type(types.array_of(types.string))
 
       # arguments are flattened
       expr = fqr('Array')[[fqr('String')]]
       expect(evaluate(expr)).to be_the_type(types.array_of(types.string))
     end
 
     it 'produces an Array[String] from the expression Array[Integer][String]' do
       expr = fqr('Array')[fqr('Integer')][fqr('String')]
       expect(evaluate(expr)).to be_the_type(types.array_of(types.string))
     end
 
     it 'produces a size constrained Array when the last two arguments specify this' do
       expr = fqr('Array')[fqr('String'), 1]
       expected_t = types.array_of(String)
       types.constrain_size(expected_t, 1, :default)
       expect(evaluate(expr)).to be_the_type(expected_t)
 
       expr = fqr('Array')[fqr('String'), 1, 2]
       expected_t = types.array_of(String)
       types.constrain_size(expected_t, 1, 2)
       expect(evaluate(expr)).to be_the_type(expected_t)
     end
 
     it "Array parameterization gives an error if parameter is not a type" do
       expr = fqr('Array')['String']
       expect { evaluate(expr)}.to raise_error(/Array-Type\[\] arguments must be types/)
     end
 
     # Tuple Type
     #
     it 'produces a Tuple[String] from the expression Tuple[String]' do
       expr = fqr('Tuple')[fqr('String')]
       expect(evaluate(expr)).to be_the_type(types.tuple(String))
 
       # arguments are flattened
       expr = fqr('Tuple')[[fqr('String')]]
       expect(evaluate(expr)).to be_the_type(types.tuple(String))
     end
 
     it "Tuple parameterization gives an error if parameter is not a type" do
       expr = fqr('Tuple')['String']
       expect { evaluate(expr)}.to raise_error(/Tuple-Type, Cannot use String where Any-Type is expected/)
     end
 
     it 'produces a varargs Tuple when the last two arguments specify size constraint' do
       expr = fqr('Tuple')[fqr('String'), 1]
       expected_t = types.tuple(String)
       types.constrain_size(expected_t, 1, :default)
       expect(evaluate(expr)).to be_the_type(expected_t)
 
       expr = fqr('Tuple')[fqr('String'), 1, 2]
       expected_t = types.tuple(String)
       types.constrain_size(expected_t, 1, 2)
       expect(evaluate(expr)).to be_the_type(expected_t)
     end
 
     # Pattern Type
     #
     it 'creates a PPatternType instance when applied to a Pattern' do
       regexp_expr = fqr('Pattern')['foo']
       expect(evaluate(regexp_expr)).to eql(Puppet::Pops::Types::TypeFactory.pattern('foo'))
     end
 
     # Regexp Type
     #
     it 'creates a Regexp instance when applied to a Pattern' do
       regexp_expr = fqr('Regexp')['foo']
       expect(evaluate(regexp_expr)).to eql(Puppet::Pops::Types::TypeFactory.regexp('foo'))
 
       # arguments are flattened
       regexp_expr = fqr('Regexp')[['foo']]
       expect(evaluate(regexp_expr)).to eql(Puppet::Pops::Types::TypeFactory.regexp('foo'))
     end
 
     # Class
     #
     it 'produces a specific class from Class[classname]' do
       expr = fqr('Class')[fqn('apache')]
       expect(evaluate(expr)).to be_the_type(types.host_class('apache'))
       expr = fqr('Class')[literal('apache')]
       expect(evaluate(expr)).to be_the_type(types.host_class('apache'))
     end
 
     it 'produces an array of Class when args are in an array' do
       # arguments are flattened
       expr = fqr('Class')[[fqn('apache')]]
       expect(evaluate(expr)[0]).to be_the_type(types.host_class('apache'))
     end
 
     it 'produces undef for Class if arg is undef' do
       # arguments are flattened
       expr = fqr('Class')[nil]
       expect(evaluate(expr)).to be_nil
     end
 
     it 'produces empty array for Class if arg is [undef]' do
       # arguments are flattened
       expr = fqr('Class')[[]]
       expect(evaluate(expr)).to be_eql([])
       expr = fqr('Class')[[nil]]
       expect(evaluate(expr)).to be_eql([])
     end
 
     it 'raises error if access is to no keys' do
       expr = fqr('Class')[fqn('apache')][]
       expect { evaluate(expr) }.to raise_error(/Evaluation Error: Class\[apache\]\[\] accepts 1 or more arguments\. Got 0/)
     end
 
     it 'produces a collection of classes when multiple class names are given' do
       expr = fqr('Class')[fqn('apache'), literal('nginx')]
       result = evaluate(expr)
       expect(result[0]).to be_the_type(types.host_class('apache'))
       expect(result[1]).to be_the_type(types.host_class('nginx'))
     end
 
     it 'removes leading :: in class name' do
       expr = fqr('Class')['::evoe']
       expect(evaluate(expr)).to be_the_type(types.host_class('evoe'))
     end
 
     it 'raises error if the name is not a valid name' do
       expr = fqr('Class')['fail-whale']
       expect { evaluate(expr) }.to raise_error(/Illegal name/)
     end
 
     it 'downcases capitalized class names' do
       expr = fqr('Class')['My::Class']
 
       expect(evaluate(expr)).to be_the_type(types.host_class('my::class'))
     end
 
     it 'gives an error if no keys are given as argument' do
       expr = fqr('Class')[]
       expect {evaluate(expr)}.to raise_error(/Evaluation Error: Class\[\] accepts 1 or more arguments. Got 0/)
     end
 
     it 'produces an empty array if the keys reduce to empty array' do
       expr = fqr('Class')[literal([[],[]])]
       expect(evaluate(expr)).to be_eql([])
     end
 
     # Resource
     it 'produces a specific resource type from Resource[type]' do
       expr = fqr('Resource')[fqr('File')]
       expect(evaluate(expr)).to be_the_type(types.resource('File'))
       expr = fqr('Resource')[literal('File')]
       expect(evaluate(expr)).to be_the_type(types.resource('File'))
     end
 
     it 'does not allow the type to be specified in an array' do
       # arguments are flattened
       expr = fqr('Resource')[[fqr('File')]]
       expect{evaluate(expr)}.to raise_error(Puppet::ParseError, /must be a resource type or a String/)
     end
 
     it 'produces a specific resource reference type from File[title]' do
       expr = fqr('File')[literal('/tmp/x')]
       expect(evaluate(expr)).to be_the_type(types.resource('File', '/tmp/x'))
     end
 
     it 'produces a collection of specific resource references when multiple titles are used' do
       # Using a resource type
       expr = fqr('File')[literal('x'),literal('y')]
       result = evaluate(expr)
       expect(result[0]).to be_the_type(types.resource('File', 'x'))
       expect(result[1]).to be_the_type(types.resource('File', 'y'))
 
       # Using generic resource
       expr = fqr('Resource')[fqr('File'), literal('x'),literal('y')]
       result = evaluate(expr)
       expect(result[0]).to be_the_type(types.resource('File', 'x'))
       expect(result[1]).to be_the_type(types.resource('File', 'y'))
     end
 
     it 'produces undef for Resource if arg is undef' do
       # arguments are flattened
       expr = fqr('File')[nil]
       expect(evaluate(expr)).to be_nil
     end
 
     it 'gives an error if no keys are given as argument to Resource' do
       expr = fqr('Resource')[]
       expect {evaluate(expr)}.to raise_error(/Evaluation Error: Resource\[\] accepts 1 or more arguments. Got 0/)
     end
 
     it 'produces an empty array if the type is given, and keys reduce to empty array for Resource' do
       expr = fqr('Resource')[fqr('File'),literal([[],[]])]
       expect(evaluate(expr)).to be_eql([])
     end
 
     it 'gives an error i no keys are given as argument to a specific Resource type' do
       expr = fqr('File')[]
       expect {evaluate(expr)}.to raise_error(/Evaluation Error: File\[\] accepts 1 or more arguments. Got 0/)
     end
 
     it 'produces an empty array if the keys reduce to empty array for a specific Resource tyoe' do
       expr = fqr('File')[literal([[],[]])]
       expect(evaluate(expr)).to be_eql([])
     end
 
     it 'gives an error if resource is not found' do
       expr = fqr('File')[fqn('x')][fqn('y')]
       expect {evaluate(expr)}.to raise_error(/Resource not found: File\['x'\]/)
     end
 
     # Type Type
     #
     it 'creates a Type instance when applied to a Type' do
       type_expr = fqr('Type')[fqr('Integer')]
       tf = Puppet::Pops::Types::TypeFactory
       expect(evaluate(type_expr)).to eql(tf.type_type(tf.integer))
 
       # arguments are flattened
       type_expr = fqr('Type')[[fqr('Integer')]]
       expect(evaluate(type_expr)).to eql(tf.type_type(tf.integer))
     end
 
     # Ruby Type
     #
     it 'creates a Ruby Type instance when applied to a Ruby Type' do
       type_expr = fqr('Runtime')['ruby','String']
       tf = Puppet::Pops::Types::TypeFactory
       expect(evaluate(type_expr)).to eql(tf.ruby_type('String'))
 
       # arguments are flattened
       type_expr = fqr('Runtime')[['ruby', 'String']]
       expect(evaluate(type_expr)).to eql(tf.ruby_type('String'))
     end
 
   end
 
   matcher :be_the_type do |type|
     calc = Puppet::Pops::Types::TypeCalculator.new
 
     match do |actual|
       calc.assignable?(actual, type) && calc.assignable?(type, actual)
     end
 
     failure_message_for_should do |actual|
       "expected #{type.to_s}, but was #{actual.to_s}"
     end
   end
 
 end
diff --git a/spec/unit/pops/evaluator/evaluating_parser_spec.rb b/spec/unit/pops/evaluator/evaluating_parser_spec.rb
index 0232a7b7a..5fd44e5ca 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',
+      "Hash[Integer,String, 1,2,3]" => 'Hash-Type[] accepts 2 to 4 arguments. Got 5',
       "'abc'[x]"                    => "The value 'x' cannot be converted to Numeric",
       "'abc'[1.0]"                  => "A String[] cannot use Float where Integer is expected",
       "'abc'[1,2,3]"                => "String supports [] with one or two arguments. Got 3",
       "Resource[0]"                 => 'First argument to Resource[] must be a resource type or a String. Got Integer',
       "Resource[a, 0]"              => 'Error creating type specialization of a Resource-Type, Cannot use Integer where a resource title String is expected',
       "File[0]"                     => 'Error creating type specialization of a File-Type, Cannot use Integer where a resource title String is expected',
       "String[a]"                   => "A Type's size constraint arguments must be a single Integer type, or 1-2 integers (or default). Got a String",
       "Pattern[0]"                  => 'Error creating type specialization of a Pattern-Type, Cannot use Integer where String or Regexp or Pattern-Type or Regexp-Type is expected',
       "Regexp[0]"                   => 'Error creating type specialization of a Regexp-Type, Cannot use Integer where String or Regexp is expected',
       "Regexp[a,b]"                 => 'A Regexp-Type[] accepts 1 argument. Got 2',
       "true[0]"                     => "Operator '[]' is not applicable to a Boolean",
       "1[0]"                        => "Operator '[]' is not applicable to an Integer",
       "3.14[0]"                     => "Operator '[]' is not applicable to a Float",
       "/.*/[0]"                     => "Operator '[]' is not applicable to a Regexp",
       "[1][a]"                      => "The value 'a' cannot be converted to Numeric",
       "[1][0.0]"                    => "An Array[] cannot use Float where Integer is expected",
       "[1]['0.0']"                  => "An Array[] cannot use Float where Integer is expected",
       "[1,2][1, 0.0]"               => "An Array[] cannot use Float where Integer is expected",
       "[1,2][1.0, -1]"              => "An Array[] cannot use Float where Integer is expected",
       "[1,2][1, -1.0]"              => "An Array[] cannot use Float where Integer is expected",
     }.each do |source, result|
       it "should parse and evaluate the expression '#{source}' to #{result}" do
         expect { parser.evaluate_string(scope, source, __FILE__)}.to raise_error(Regexp.new(Regexp.quote(result)))
       end
     end
 
     context "on catalog types" do
       it "[n] gets resource parameter [n]" do
         source = "notify { 'hello': message=>'yo'} Notify[hello][message]"
         parser.evaluate_string(scope, source, __FILE__).should == 'yo'
       end
 
       it "[n] gets class parameter [n]" do
         source = "class wonka($produces='chocolate'){ }
            include wonka
            Class[wonka][produces]"
 
         # This is more complicated since it needs to run like 3.x and do an import_ast
         adapted_parser = Puppet::Parser::E4ParserAdapter.new
         adapted_parser.file = __FILE__
         ast = adapted_parser.parse(source)
         Puppet.override({:global_scope => scope,
                          :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
           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
           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
         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_parser_spec.rb b/spec/unit/pops/types/type_parser_spec.rb
index b2d85056f..080e3b44a 100644
--- a/spec/unit/pops/types/type_parser_spec.rb
+++ b/spec/unit/pops/types/type_parser_spec.rb
@@ -1,240 +1,240 @@
 require 'spec_helper'
 require 'puppet/pops'
 
 describe Puppet::Pops::Types::TypeParser do
   extend RSpec::Matchers::DSL
 
   let(:parser) { Puppet::Pops::Types::TypeParser.new }
   let(:types)  { Puppet::Pops::Types::TypeFactory }
 
 
   it "rejects a puppet expression" do
     expect { parser.parse("1 + 1") }.to raise_error(Puppet::ParseError, /The expression <1 \+ 1> is not a valid type specification/)
   end
 
   it "rejects a empty type specification" do
     expect { parser.parse("") }.to raise_error(Puppet::ParseError, /The expression <> is not a valid type specification/)
   end
 
   it "rejects an invalid type simple type" do
     expect { parser.parse("notAType") }.to raise_error(Puppet::ParseError, /The expression <notAType> is not a valid type specification/)
   end
 
   it "rejects an unknown parameterized type" do
     expect { parser.parse("notAType[Integer]") }.to raise_error(Puppet::ParseError,
       /The expression <notAType\[Integer\]> is not a valid type specification/)
   end
 
   it "rejects an unknown type parameter" do
     expect { parser.parse("Array[notAType]") }.to raise_error(Puppet::ParseError,
       /The expression <Array\[notAType\]> is not a valid type specification/)
   end
 
   [
     'Any', 'Data', 'CatalogEntry', 'Boolean', 'Scalar', 'Undef', 'Numeric', 'Default'
   ].each do |name|
     it "does not support parameterizing unparameterized type <#{name}>" do
       expect { parser.parse("#{name}[Integer]") }.to raise_unparameterized_error_for(name)
     end
   end
 
   it "parses a simple, unparameterized type into the type object" do
     expect(the_type_parsed_from(types.any)).to be_the_type(types.any)
     expect(the_type_parsed_from(types.integer)).to be_the_type(types.integer)
     expect(the_type_parsed_from(types.float)).to be_the_type(types.float)
     expect(the_type_parsed_from(types.string)).to be_the_type(types.string)
     expect(the_type_parsed_from(types.boolean)).to be_the_type(types.boolean)
     expect(the_type_parsed_from(types.pattern)).to be_the_type(types.pattern)
     expect(the_type_parsed_from(types.data)).to be_the_type(types.data)
     expect(the_type_parsed_from(types.catalog_entry)).to be_the_type(types.catalog_entry)
     expect(the_type_parsed_from(types.collection)).to be_the_type(types.collection)
     expect(the_type_parsed_from(types.tuple)).to be_the_type(types.tuple)
     expect(the_type_parsed_from(types.struct)).to be_the_type(types.struct)
     expect(the_type_parsed_from(types.optional)).to be_the_type(types.optional)
     expect(the_type_parsed_from(types.default)).to be_the_type(types.default)
   end
 
   it "interprets an unparameterized Array as an Array of Data" do
     expect(parser.parse("Array")).to be_the_type(types.array_of_data)
   end
 
   it "interprets an unparameterized Hash as a Hash of Scalar to Data" do
     expect(parser.parse("Hash")).to be_the_type(types.hash_of_data)
   end
 
   it "interprets a parameterized Hash[t] as a Hash of Scalar to t" do
-    expect(parser.parse("Hash[Integer]")).to be_the_type(types.hash_of(types.integer))
+    expect(parser.parse("Hash[Scalar, Integer]")).to be_the_type(types.hash_of(types.integer))
   end
 
   it "parses a parameterized type into the type object" do
     parameterized_array = types.array_of(types.integer)
     parameterized_hash = types.hash_of(types.integer, types.boolean)
 
     expect(the_type_parsed_from(parameterized_array)).to be_the_type(parameterized_array)
     expect(the_type_parsed_from(parameterized_hash)).to be_the_type(parameterized_hash)
   end
 
   it "parses a size constrained collection using capped range" do
     parameterized_array = types.array_of(types.integer)
     types.constrain_size(parameterized_array, 1,2)
     parameterized_hash = types.hash_of(types.integer, types.boolean)
     types.constrain_size(parameterized_hash, 1,2)
 
     expect(the_type_parsed_from(parameterized_array)).to be_the_type(parameterized_array)
     expect(the_type_parsed_from(parameterized_hash)).to be_the_type(parameterized_hash)
   end
 
   it "parses a size constrained collection with open range" do
     parameterized_array = types.array_of(types.integer)
     types.constrain_size(parameterized_array, 1,:default)
     parameterized_hash = types.hash_of(types.integer, types.boolean)
     types.constrain_size(parameterized_hash, 1,:default)
 
     expect(the_type_parsed_from(parameterized_array)).to be_the_type(parameterized_array)
     expect(the_type_parsed_from(parameterized_hash)).to be_the_type(parameterized_hash)
   end
 
   it "parses optional type" do
     opt_t = types.optional(Integer)
     expect(the_type_parsed_from(opt_t)).to be_the_type(opt_t)
   end
 
   it "parses tuple type" do
     tuple_t = types.tuple(Integer, String)
     expect(the_type_parsed_from(tuple_t)).to be_the_type(tuple_t)
   end
 
   it "parses tuple type with occurrence constraint" do
     tuple_t = types.tuple(Integer, String)
     types.constrain_size(tuple_t, 2, 5)
     expect(the_type_parsed_from(tuple_t)).to be_the_type(tuple_t)
   end
 
   it "parses struct type" do
     struct_t = types.struct({'a'=>Integer, 'b'=>String})
     expect(the_type_parsed_from(struct_t)).to be_the_type(struct_t)
   end
 
   describe "handles parsing of patterns and regexp" do
     { 'Pattern[/([a-z]+)([1-9]+)/]'        => [:pattern, [/([a-z]+)([1-9]+)/]],
       'Pattern["([a-z]+)([1-9]+)"]'        => [:pattern, [/([a-z]+)([1-9]+)/]],
       'Regexp[/([a-z]+)([1-9]+)/]'         => [:regexp,  [/([a-z]+)([1-9]+)/]],
       'Pattern[/x9/, /([a-z]+)([1-9]+)/]'  => [:pattern, [/x9/, /([a-z]+)([1-9]+)/]],
     }.each do |source, type|
       it "such that the source '#{source}' yields the type #{type.to_s}" do
         expect(parser.parse(source)).to be_the_type(Puppet::Pops::Types::TypeFactory.send(type[0], *type[1]))
       end
     end
   end
 
   it "rejects an collection spec with the wrong number of parameters" do
     expect { parser.parse("Array[Integer, 1,2,3]") }.to raise_the_parameter_error("Array", "1 to 3", 4)
-    expect { parser.parse("Hash[Integer, Integer, 1,2,3]") }.to raise_the_parameter_error("Hash", "1 to 4", 5)
+    expect { parser.parse("Hash[Integer, Integer, 1,2,3]") }.to raise_the_parameter_error("Hash", "2 to 4", 5)
   end
 
   it "interprets anything that is not a built in type to be a resource type" do
     expect(parser.parse("File")).to be_the_type(types.resource('file'))
   end
 
   it "parses a resource type with title" do
     expect(parser.parse("File['/tmp/foo']")).to be_the_type(types.resource('file', '/tmp/foo'))
   end
 
   it "parses a resource type using 'Resource[type]' form" do
     expect(parser.parse("Resource[File]")).to be_the_type(types.resource('file'))
   end
 
   it "parses a resource type with title using 'Resource[type, title]'" do
     expect(parser.parse("Resource[File, '/tmp/foo']")).to be_the_type(types.resource('file', '/tmp/foo'))
   end
 
   it "parses a host class type" do
     expect(parser.parse("Class")).to be_the_type(types.host_class())
   end
 
   it "parses a parameterized host class type" do
     expect(parser.parse("Class[foo::bar]")).to be_the_type(types.host_class('foo::bar'))
   end
 
   it 'parses an integer range' do
    expect(parser.parse("Integer[1,2]")).to be_the_type(types.range(1,2))
   end
 
   it 'parses a float range' do
    expect(parser.parse("Float[1.0,2.0]")).to be_the_type(types.float_range(1.0,2.0))
   end
 
   it 'parses a collection size range' do
    expect(parser.parse("Collection[1,2]")).to be_the_type(types.constrain_size(types.collection,1,2))
   end
 
   it 'parses a type type' do
     expect(parser.parse("Type[Integer]")).to be_the_type(types.type_type(types.integer))
   end
 
   it 'parses a ruby type' do
     expect(parser.parse("Runtime[ruby, 'Integer']")).to be_the_type(types.ruby_type('Integer'))
   end
 
   it 'parses a callable type' do
     expect(parser.parse("Callable")).to be_the_type(types.all_callables())
   end
 
   it 'parses a parameterized callable type' do
     expect(parser.parse("Callable[String, Integer]")).to be_the_type(types.callable(String, Integer))
   end
 
   it 'parses a parameterized callable type with min/max' do
     expect(parser.parse("Callable[String, Integer, 1, default]")).to be_the_type(types.callable(String, Integer, 1, :default))
   end
 
   it 'parses a parameterized callable type with block' do
     expect(parser.parse("Callable[String, Callable[Boolean]]")).to be_the_type(types.callable(String, types.callable(true)))
   end
 
   it 'parses a parameterized callable type with 0 min/max' do
     t = parser.parse("Callable[0,0]")
     expect(t).to be_the_type(types.callable())
     expect(t.param_types.types).to be_empty
   end
 
   it 'parses a parameterized callable type with >0 min/max' do
     t = parser.parse("Callable[0,1]")
     expect(t).to be_the_type(types.callable(0,1))
     # Contains a Unit type to indicate "called with what you accept"
     expect(t.param_types.types[0]).to be_the_type(Puppet::Pops::Types::PUnitType.new())
   end
 
   matcher :be_the_type do |type|
     calc = Puppet::Pops::Types::TypeCalculator.new
 
     match do |actual|
       calc.assignable?(actual, type) && calc.assignable?(type, actual)
     end
 
     failure_message_for_should do |actual|
       "expected #{calc.string(type)}, but was #{calc.string(actual)}"
     end
   end
 
   def raise_the_parameter_error(type, required, given)
     raise_error(Puppet::ParseError, /#{type} requires #{required}, #{given} provided/)
   end
 
   def raise_type_error_for(type_name)
     raise_error(Puppet::ParseError, /Unknown type <#{type_name}>/)
   end
 
   def raise_unparameterized_error_for(type_name)
     raise_error(Puppet::ParseError, /Not a parameterized type <#{type_name}>/)
   end
 
   def the_type_parsed_from(type)
     parser.parse(the_type_spec_for(type))
   end
 
   def the_type_spec_for(type)
     calc = Puppet::Pops::Types::TypeCalculator.new
     calc.string(type)
   end
 end