puppet 4.2.3 → 4.3.0

data/lib/puppet/pops/types/type_parser.rb

@@ -11,9 +11,8 @@ class Puppet::Pops::Types::TypeParser
 
   # @api public
   def initialize
-    @parser = Puppet::Pops::Parser::Parser.new()
-    @type_transformer = Puppet::Pops::Visitor.new(nil, "interpret", 0, 0)
-    @undef_t = TYPES.undef
+    @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.
@@ -113,87 +112,87 @@ class Puppet::Pops::Types::TypeParser
   # @api private
   def interpret_QualifiedReference(name_ast)
     case name_ast.value
-    when "integer"
+    when 'integer'
       TYPES.integer
 
-    when "float"
+    when 'float'
       TYPES.float
 
-    when "numeric"
+    when 'numeric'
         TYPES.numeric
 
-    when "string"
+    when 'string'
       TYPES.string
 
-    when "enum"
+    when 'enum'
       TYPES.enum
 
-    when "boolean"
+    when 'boolean'
       TYPES.boolean
 
-    when "pattern"
+    when 'pattern'
       TYPES.pattern
 
-    when "regexp"
+    when 'regexp'
       TYPES.regexp
 
-    when "data"
+    when 'data'
       TYPES.data
 
-    when "array"
+    when 'array'
       TYPES.array_of_data
 
-    when "hash"
+    when 'hash'
       TYPES.hash_of_data
 
-    when "class"
-      TYPES.host_class()
+    when 'class'
+      TYPES.host_class
 
-    when "resource"
-      TYPES.resource()
+    when 'resource'
+      TYPES.resource
 
-    when "collection"
-      TYPES.collection()
+    when 'collection'
+      TYPES.collection
 
-    when "scalar"
-      TYPES.scalar()
+    when 'scalar'
+      TYPES.scalar
 
-    when "catalogentry"
-      TYPES.catalog_entry()
+    when 'catalogentry'
+      TYPES.catalog_entry
 
-    when "undef"
-      TYPES.undef()
+    when 'undef'
+      TYPES.undef
 
-    when "notundef"
+    when 'notundef'
       TYPES.not_undef()
 
-    when "default"
+    when 'default'
       TYPES.default()
+ 
+    when 'any'
+      TYPES.any
 
-    when "any"
-      TYPES.any()
+    when 'variant'
+      TYPES.variant
 
-    when "variant"
-      TYPES.variant()
+    when 'optional'
+      TYPES.optional
 
-    when "optional"
-      TYPES.optional()
+    when 'runtime'
+      TYPES.runtime
 
-    when "runtime"
-      TYPES.runtime()
+    when 'type'
+      TYPES.type_type
 
-    when "type"
-      TYPES.type_type()
+    when 'tuple'
+      TYPES.tuple
 
-    when "tuple"
-      TYPES.tuple()
+    when 'struct'
+      TYPES.struct
 
-    when "struct"
-      TYPES.struct()
-
-    when "callable"
+    when 'callable'
       # A generic callable as opposed to one that does not accept arguments
-      TYPES.all_callables()
+      TYPES.all_callables
 
     else
       TYPES.resource(name_ast.value)
@@ -209,118 +208,112 @@ class Puppet::Pops::Types::TypeParser
     end
 
     case parameterized_ast.left_expr.value
-    when "array"
+    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
+          if parameters[1].is_a?(Puppet::Pops::Types::PIntegerType)
+            parameters[1]
+          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)
+        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
+      TYPES.array_of(parameters[0], size_type)
 
-    when "hash"
-      result = case parameters.size
+    when 'hash'
+      case parameters.size
       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
+          if parameters[2].is_a?(Puppet::Pops::Types::PIntegerType)
+            parameters[2]
+          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])
+        TYPES.hash_of(parameters[1], parameters[0], size_type)
       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])
+        TYPES.hash_of(parameters[1], parameters[0], TYPES.range(parameters[2], parameters[3]))
       else
-        raise_invalid_parameters_error("Hash", "2 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"
+    when 'collection'
       size_type = case parameters.size
-      when 1
-        if parameters[0].is_a?(Puppet::Pops::Types::PIntegerType)
-          parameters[0].copy
-        else
+        when 1
+          if parameters[0].is_a?(Puppet::Pops::Types::PIntegerType)
+            parameters[0]
+          else
+            assert_range_parameter(parameters[0])
+            TYPES.range(parameters[0], :default)
+          end
+        when 2
           assert_range_parameter(parameters[0])
-          TYPES.range(parameters[0], :default)
+          assert_range_parameter(parameters[1])
+          TYPES.range(parameters[0], parameters[1])
+        else
+          raise_invalid_parameters_error('Collection', '1 to 2', parameters.size)
         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
+      TYPES.collection(size_type)
 
-    when "class"
+    when 'class'
       if parameters.size != 1
-        raise_invalid_parameters_error("Class", 1, parameters.size)
+        raise_invalid_parameters_error('Class', 1, parameters.size)
       end
       TYPES.host_class(parameters[0])
 
-    when "resource"
+    when 'resource'
       if parameters.size == 1
         TYPES.resource(parameters[0])
       elsif parameters.size != 2
-        raise_invalid_parameters_error("Resource", "1 or 2", parameters.size)
+        raise_invalid_parameters_error('Resource', '1 or 2', parameters.size)
       else
         TYPES.resource(parameters[0], parameters[1])
       end
 
-    when "regexp"
+    when 'regexp'
       # 1 parameter being a string, or regular expression
-      raise_invalid_parameters_error("Regexp", "1", parameters.size) unless parameters.size == 1
+      raise_invalid_parameters_error('Regexp', '1', parameters.size) unless parameters.size == 1
       TYPES.regexp(parameters[0])
 
-    when "enum"
+    when 'enum'
       # 1..m parameters being strings
-      raise_invalid_parameters_error("Enum", "1 or more", parameters.size) unless parameters.size >= 1
+      raise_invalid_parameters_error('Enum', '1 or more', parameters.size) unless parameters.size >= 1
       TYPES.enum(*parameters)
 
-    when "pattern"
+    when 'pattern'
       # 1..m parameters being strings or regular expressions
-      raise_invalid_parameters_error("Pattern", "1 or more", parameters.size) unless parameters.size >= 1
+      raise_invalid_parameters_error('Pattern', '1 or more', parameters.size) unless parameters.size >= 1
       TYPES.pattern(*parameters)
 
-    when "variant"
+    when 'variant'
       # 1..m parameters being strings or regular expressions
-      raise_invalid_parameters_error("Variant", "1 or more", parameters.size) unless parameters.size >= 1
+      raise_invalid_parameters_error('Variant', '1 or more', parameters.size) unless parameters.size >= 1
       TYPES.variant(*parameters)
 
-    when "tuple"
+    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
+      raise_invalid_parameters_error('Tuple', '1 or more', parameters.size) unless parameters.size >= 1
       length = parameters.size
+      size_type = nil
       if TYPES.is_range_parameter?(parameters[-2])
         # min, max specification
         min = parameters[-2]
@@ -329,30 +322,28 @@ class Puppet::Pops::Types::TypeParser
         max = parameters[-1]
         max = max == :default ? nil : max
         parameters = parameters[0, length-2]
+        size_type = TYPES.range(min, max)
       elsif TYPES.is_range_parameter?(parameters[-1])
         min = parameters[-1]
         min = (min == :default || min == 'default') ? 0 : min
         max = nil
         parameters = parameters[0, length-1]
+        size_type = TYPES.range(min, max)
       end
-      t = TYPES.tuple(*parameters)
-      if min || max
-        TYPES.constrain_size(t, min, max)
-      end
-      t
+      TYPES.tuple(parameters, size_type)
 
-    when "callable"
+    when 'callable'
       # 1..m parameters being types (last three optionally integer or literal default, and a callable)
       TYPES.callable(*parameters)
 
-    when "struct"
+    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
+      raise_invalid_parameters_error('Struct', '1', parameters.size) unless parameters.size == 1
       h = parameters[0]
       raise_invalid_type_specification_error unless h.is_a?(Hash)
       TYPES.struct(h)
 
-    when "integer"
+    when 'integer'
       if parameters.size == 1
         case parameters[0]
         when Integer
@@ -361,12 +352,12 @@ class Puppet::Pops::Types::TypeParser
           TYPES.integer # unbound
         end
       elsif parameters.size != 2
-        raise_invalid_parameters_error("Integer", "1 or 2", parameters.size)
+        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"
+    when 'float'
       if parameters.size == 1
         case parameters[0]
         when Integer, Float
@@ -375,17 +366,17 @@ class Puppet::Pops::Types::TypeParser
           TYPES.float # unbound
         end
       elsif parameters.size != 2
-        raise_invalid_parameters_error("Float", "1 or 2", parameters.size)
+        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"
+    when 'string'
       size_type =
       case parameters.size
       when 1
         if parameters[0].is_a?(Puppet::Pops::Types::PIntegerType)
-          parameters[0].copy
+          parameters[0]
         else
           assert_range_parameter(parameters[0])
           TYPES.range(parameters[0], :default)
@@ -395,24 +386,22 @@ class Puppet::Pops::Types::TypeParser
         assert_range_parameter(parameters[1])
         TYPES.range(parameters[0], parameters[1])
       else
-        raise_invalid_parameters_error("String", "1 to 2", parameters.size)
+        raise_invalid_parameters_error('String', '1 to 2', parameters.size)
       end
-      result = TYPES.string
-      result.size_type = size_type
-      result
+      TYPES.string(size_type)
 
-    when "optional"
+    when 'optional'
       if parameters.size != 1
-        raise_invalid_parameters_error("Optional", 1, parameters.size)
+        raise_invalid_parameters_error('Optional', 1, parameters.size)
       end
       param = parameters[0]
       assert_type(param) unless param.is_a?(String)
       TYPES.optional(param)
 
-    when "any", "data", "catalogentry", "boolean", "scalar", "undef", "numeric", "default"
+    when 'any', 'data', 'catalogentry', 'boolean', 'scalar', 'undef', 'numeric', 'default'
       raise_unparameterized_type_error(parameterized_ast.left_expr)
 
-    when "notundef"
+    when 'notundef'
       case parameters.size
       when 0
         TYPES.not_undef
@@ -424,15 +413,15 @@ class Puppet::Pops::Types::TypeParser
         raise_invalid_parameters_error("NotUndef", "0 to 1", parameters.size)
       end
 
-    when "type"
+    when 'type'
       if parameters.size != 1
-        raise_invalid_parameters_error("Type", 1, parameters.size)
+        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
+    when 'runtime'
+      raise_invalid_parameters_error('Runtime', '2', parameters.size) unless parameters.size == 2
       TYPES.runtime(*parameters)
 
     else
@@ -476,6 +465,6 @@ class Puppet::Pops::Types::TypeParser
 
   def original_text_of(ast)
     position = Puppet::Pops::Adapters::SourcePosAdapter.adapt(ast)
-    position.extract_text()
+    position.extract_text
   end
 end

data/lib/puppet/pops/types/types.rb

@@ -1,415 +1,1554 @@
 require 'rgen/metamodel_builder'
 
 # The Types model is a model of Puppet Language types.
-# It consists of two parts; the meta-model expressed using RGen (in types_meta.rb) and this file which
-# mixes in the implementation.
+#
+# The exact relationship between types is not visible in this model wrt. the PDataType which is an abstraction
+# of Scalar, Array[Data], and Hash[Scalar, Data] nested to any depth. This means it is not possible to
+# infer the type by simply looking at the inheritance hierarchy. The {Puppet::Pops::Types::TypeCalculator} should
+# be used to answer questions about types. The {Puppet::Pops::Types::TypeFactory} should be used to create an instance
+# of a type whenever one is needed.
+#
+# The implementation of the Types model contains methods that are required for the type objects to behave as
+# expected when comparing them and using them as keys in hashes. (No other logic is, or should be included directly in
+# the model's classes).
 #
 # @api public
 #
 module Puppet::Pops
-  require 'puppet/pops/types/types_meta'
-
   # TODO: See PUP-2978 for possible performance optimization
-
-  # Mix in implementation part of the Bindings Module
   module Types
-    class TypeModelObject < RGen::MetamodelBuilder::MMBase
+    class TypedModelObject < Object
       include Puppet::Pops::Visitable
       include Puppet::Pops::Adaptable
-      include Puppet::Pops::Containment
     end
 
-    class PAnyType < TypeModelObject
-      module ClassModule
-        # Produce a deep copy of the type
-        def copy
-          Marshal.load(Marshal.dump(self))
+    # Base type for all types
+    # @api public
+    #
+    class PAnyType < TypedModelObject
+      # Checks if _o_ is a type that is assignable to this type.
+      # If _o_ is a `Class` then it is first converted to a type.
+      # If _o_ is a Variant, then it is considered assignable when all its types are assignable
+      # @return [Boolean] `true` when _o_ is assignable to this type
+      # @api public
+      def assignable?(o)
+        case o
+          when Class
+          # Safe to call _assignable directly since a Class never is a Unit or Variant
+          _assignable?(Puppet::Pops::Types::TypeCalculator.singleton.type(o))
+        when PUnitType
+          true
+        when PVariantType
+          # Assignable if all contained types are assignable
+          o.types.all? { |vt| assignable?(vt) }
+        when PNotUndefType
+          if !(o.type.nil? || o.type.assignable?(PUndefType::DEFAULT))
+            assignable?(o.type)
+          else
+            _assignable?(o)
+          end
+        else
+          _assignable?(o)
         end
+      end
+
+      # Returns `true` if this instance is a callable that accepts the given _args_
+      #
+      # @return [Boolean]
+      def callable?(args)
+        args.is_a?(PAnyType) && kind_of_callable? && args.callable_args?(self)
+      end
+
+      # Returns `true` if this instance is considered valid as arguments to _callable_
+      # @return [Boolean]
+      # @api private
+      def callable_args?(callable)
+        false
+      end
+
+      # Subclasses that are enumerable will override this method to return `true`
+      # @return [Boolean] false#
+      def enumerable?
+        is_a?(Enumerable)
+      end
+
+      # Generalizes value specific types. Types that are not value specific will return `self` otherwize
+      # the generalized type is returned.
+      #
+      # @return [PAnyType] The generalized type
+      # @api public
+      def generalize
+        # Applicable to all types that have no variables
+        self
+      end
+
+      # Responds `true` for all callables, variants of callables and unless _optional_ is
+      # false, all optional callables.
+      # @return [Boolean] `true`if this type is considered callable
+      # @api private
+      def kind_of_callable?(optional=true)
+        false
+      end
+
+      def hash
+        self.class.hash
+      end
+
+      # Returns true if the given argument _o_ is an instance of this type
+      # @return [Boolean]
+      def instance?(o)
+        true
+      end
+
+      def ==(o)
+        self.class == o.class
+      end
+
+      alias eql? ==
+
+      # Strips the class name from all module prefixes, the leading 'P' and the ending 'Type'. I.e.
+      # an instance of Puppet::Pops::Types::PVariantType will return 'Variant'
+      # @return [String] the simple name of this type
+      def simple_name
+        n = self.class.name
+        n[n.rindex('::')+3..n.size-5]
+      end
+
+      def to_s
+        Puppet::Pops::Types::TypeCalculator.string(self)
+      end
+
+      # The default instance of this type. Each type in the type system has this constant
+      # declared.
+      #
+      DEFAULT = PAnyType.new
+
+      protected
+
+      # @api private
+      def _assignable?(o)
+        o.is_a?(PAnyType)
+      end
 
-        def hash
-          self.class.hash
+      NAME_SEGMENT_SEPARATOR = '::'.freeze
+
+      # @api private
+      def class_from_string(str)
+        begin
+          str.split(NAME_SEGMENT_SEPARATOR).reduce(Object) do |memo, name_segment|
+            memo.const_get(name_segment)
+          end
+        rescue NameError
+          return nil
         end
+      end
 
-        def ==(o)
-          self.class == o.class
+      # Produces the tuple entry at the given index given a tuple type, its from/to constraints on the last
+      # type, and an index.
+      # Produces nil if the index is out of bounds
+      # from must be less than to, and from may not be less than 0
+      #
+      # @api private
+      #
+      def tuple_entry_at(tuple_t, from, to, index)
+        regular = (tuple_t.types.size - 1)
+        if index < regular
+          tuple_t.types[index]
+        elsif index < regular + to
+          # in the varargs part
+          tuple_t.types[-1]
+        else
+          nil
         end
+      end
 
-        alias eql? ==
 
-        def to_s
-          Puppet::Pops::Types::TypeCalculator.string(self)
+      # Transform size_type to min, max
+      # if size_type == nil the constraint is 1,1
+      # if size_type.from == nil min size = 1
+      # if size_type.to == nil max size == Infinity
+      #
+      # @api private
+      def type_to_range(size_type)
+        return [1,1] if size_type.nil?
+        from = size_type.from
+        to = size_type.to
+        [from.nil? ? 1 : from, to.nil? ? Float::INFINITY : to]
+      end
+    end
+
+    # The type of types.
+    # @api public
+    #
+    class PType < PAnyType
+      attr_reader :type
+
+      def initialize(type)
+        @type = type
+      end
+
+      def instance?(o)
+        if o.is_a?(PAnyType)
+          type.nil? || type.assignable?(o)
+        else
+          assignable?(TypeCalculator.infer(o))
         end
       end
+
+      def generalize
+        @type.nil? ? DEFAULT : PType.new(type.generalize)
+      end
+
+      def hash
+        31 * @type.hash
+      end
+
+      def ==(o)
+        self.class == o.class && @type == o.type
+      end
+
+      def simple_name
+        # since this the class is inconsistently named PType and not PTypeType
+        'Type'
+      end
+
+      DEFAULT = PType.new(nil)
+
+      protected
+
+      # @api private
+      def _assignable?(o)
+        return false unless o.is_a?(PType)
+        return true if @type.nil? # wide enough to handle all types
+        return false if o.type.nil? # wider than t
+        @type.assignable?(o.type)
+      end
     end
 
     class PNotUndefType < PAnyType
-      module ClassModule
-        def hash
-          [self.class, type].hash
-        end
+      attr_reader :type
 
-        def ==(o)
-          self.class == o.class && type == o.type
-        end
+      def initialize(type = nil)
+        @type = type.class == PAnyType ? nil : type
+      end
+
+      def instance?(o)
+        !(o.nil? || o == :undef) && (@type.nil? || @type.instance?(o))
+      end
+
+      def generalize
+        @type.nil? ? DEFAULT : PNotUndefType.new(type.generalize)
+      end
+
+      def hash
+        31 * @type.hash
+      end
+
+      def ==(o)
+        self.class == o.class && @type == o.type
+      end
+
+      DEFAULT = PNotUndefType.new
+
+      protected
+
+      # @api private
+      def _assignable?(o)
+        o.is_a?(PAnyType) && !o.assignable?(PUndefType::DEFAULT) && (@type.nil? || @type.assignable?(o))
       end
     end
 
-    class PType < PAnyType
-      module ClassModule
-        def hash
-          [self.class, type].hash
-        end
+    # @api public
+    #
+    class PUndefType < PAnyType
+      def instance?(o)
+        o.nil? || o == :undef
+      end
 
-        def ==(o)
-          self.class == o.class && type == o.type
-        end
+      # @api private
+      def callable_args?(callable_t)
+        # if callable_t is Optional (or indeed PUndefType), this means that 'missing callable' is accepted
+        callable_t.assignable?(DEFAULT)
+      end
+
+      DEFAULT = PUndefType.new
+
+      protected
+      # @api private
+      def _assignable?(o)
+        o.is_a?(PUndefType)
+      end
+    end
+
+    # A type private to the type system that describes "ignored type" - i.e. "I am what you are"
+    # @api private
+    #
+    class PUnitType < PAnyType
+      def instance?(o)
+        true
+      end
+
+      DEFAULT = PUnitType.new
+
+      protected
+      # @api private
+      def _assignable?(o)
+        true
+      end
+    end
+
+    # @api public
+    #
+    class PDefaultType < PAnyType
+      def instance?(o)
+        o == :default
+      end
+
+      DEFAULT = PDefaultType.new
+
+      protected
+      # @api private
+      def _assignable?(o)
+        o.is_a?(PDefaultType)
       end
     end
 
+    # A flexible data type, being assignable to its subtypes as well as PArrayType and PHashType with element type assignable to PDataType.
+    #
+    # @api public
+    #
     class PDataType < PAnyType
-      module ClassModule
-        def ==(o)
-          self.class == o.class ||
-            o.class == PVariantType && o == Puppet::Pops::Types::TypeCalculator.data_variant()
+      def ==(o)
+        self.class == o.class || o.class == PVariantType && o == PVariantType::DATA
+      end
+
+      def instance?(o)
+        PVariantType::DATA.instance?(o)
+      end
+
+      DEFAULT = PDataType.new
+
+      protected
+
+      # Data is assignable by other Data and by Array[Data] and Hash[Scalar, Data]
+      # @api private
+      def _assignable?(o)
+        # We cannot put the NotUndefType[Data] in the @data_variant_t since that causes an endless recursion
+        case o
+        when Types::PDataType
+          true
+        when Types::PNotUndefType
+          assignable?(o.type || PUndefType::DEFAULT)
+        else
+          PVariantType::DATA.assignable?(o)
         end
       end
     end
 
-    class PVariantType < PAnyType
-      module ClassModule
+    # Type that is PDataType compatible, but is not a PCollectionType.
+    # @api public
+    #
+    class PScalarType < PAnyType
 
-        def hash
-          [self.class, Set.new(self.types)].hash
-        end
+      def instance?(o)
+        assignable?(TypeCalculator.infer(o))
+      end
 
-        def ==(o)
-          (self.class == o.class && Set.new(types) == Set.new(o.types)) ||
-            (o.class == PDataType && self == Puppet::Pops::Types::TypeCalculator.data_variant())
-        end
+      DEFAULT = PScalarType.new
+
+      protected
+
+      # @api private
+      def _assignable?(o)
+        o.is_a?(PScalarType)
       end
     end
 
+    # A string type describing the set of strings having one of the given values
+    # @api public
+    #
     class PEnumType < PScalarType
-      module ClassModule
-        def hash
-          [self.class, Set.new(self.values)].hash
-        end
+      include Enumerable
 
-        def ==(o)
-          self.class == o.class && Set.new(values) == Set.new(o.values)
-        end
+      attr_reader :values
+
+      def initialize(values)
+        @values = values.sort.freeze
       end
-    end
 
-    class PIntegerType < PNumericType
-      module ClassModule
-        # The integer type is enumerable when it defines a range
-        include Enumerable
-
-        # Returns Float.Infinity if one end of the range is unbound
-        def size
-          return Float::INFINITY if from.nil? || to.nil?
-          1+(to-from).abs
-        end
-
-        # Returns the range as an array ordered so the smaller number is always first.
-        # The number may be Infinity or -Infinity.
-        def range
-          f = from || -Float::INFINITY
-          t = to || Float::INFINITY
-          if f < t
-            [f, t]
-          else
-            [t,f]
-          end
+      # Returns Enumerator if no block is given, otherwise, calls the given
+      # block with each of the strings for this enum
+      def each
+        if block_given?
+          values.each { |x| yield x }
+        else
+          values.to_enum
         end
+      end
 
-        # Returns Enumerator if no block is given
-        # Returns self if size is infinity (does not yield)
-        def each
-          return self.to_enum unless block_given?
-          return nil if from.nil? || to.nil?
-          if to < from
-            from.downto(to) {|x| yield x }
+      def hash
+        @values.hash
+      end
+
+      def ==(o)
+        self.class == o.class && @values == o.values
+      end
+
+      DEFAULT = PEnumType.new([])
+
+      protected
+
+      # @api private
+      def _assignable?(o)
+        return true if self == o
+        svalues = values
+        if svalues.empty?
+          return true if o.is_a?(PStringType) || o.is_a?(PEnumType) || o.is_a?(PPatternType)
+        end
+        case o
+          when PStringType
+            # if the set of strings are all found in the set of enums
+            !o.values.empty? && o.values.all? { |s| svalues.any? { |e| e == s }}
+          when PEnumType
+            !o.values.empty? && o.values.all? { |s| svalues.any? {|e| e == s }}
           else
-            from.upto(to) {|x| yield x }
-          end
+            false
         end
+      end
+    end
 
-        def hash
-          [self.class, from, to].hash
+    # @api public
+    #
+    class PNumericType < PScalarType
+      def initialize(from, to = Float::INFINITY)
+        from = -Float::INFINITY if from.nil? || from == :default
+        to = Float::INFINITY if to.nil? || to == :default
+
+        # Always create in right order
+        if from <= to
+          @from = from
+          @to = to
+        else
+          @to = from
+          @from = to
         end
+      end
+
+      # Returns the lower bound of the numeric range or `nil` if no lower bound is set.
+      # @return [Float,Integer]
+      def from
+        @from == -Float::INFINITY ? nil : @from
+      end
+
+      # Returns the upper bound of the numeric range or `nil` if no upper bound is set.
+      # @return [Float,Integer]
+      def to
+        @to == Float::INFINITY ? nil : @to
+      end
+
+      # Same as #from but will return `-Float::Infinity` instead of `nil` if no lower bound is set.
+      # @return [Float,Integer]
+      def numeric_from
+        @from
+      end
+
+      # Same as #to but will return `Float::Infinity` instead of `nil` if no lower bound is set.
+      # @return [Float,Integer]
+      def numeric_to
+        @to
+      end
+
+      def hash
+        @from.hash * 31 + @to.hash
+      end
+
+      def ==(o)
+        self.class == o.class && @from == o.numeric_from && @to == o.numeric_to
+      end
+
+      def instance?(o)
+        o.is_a?(Numeric) && o >= @from && o <= @to
+      end
+
+      def unbounded?
+        @from == -Float::INFINITY && @to == Float::INFINITY
+      end
+
+      DEFAULT = PNumericType.new(-Float::INFINITY)
+
+      protected
+
+      # @api_private
+      def _assignable?(o)
+        return false unless o.is_a?(self.class)
+        # If o min and max are within the range of t
+        @from <= o.numeric_from && @to >= o.numeric_to
+      end
+    end
+
+    # @api public
+    #
+    class PIntegerType < PNumericType
+      # The integer type is enumerable when it defines a range
+      include Enumerable
+
+      def enumerable?
+        @from != -Float::INFINITY && @to != Float::INFINITY
+      end
+
+      def generalize
+        DEFAULT
+      end
+
+      def instance?(o)
+        o.is_a?(Integer) && o >= numeric_from && o <= numeric_to
+      end
+
+      # Returns Float.Infinity if one end of the range is unbound
+      def size
+        return Float::INFINITY if @from == -Float::INFINITY || @to == Float::INFINITY
+        1+(to-from).abs
+      end
+
+      # Returns the range as an array ordered so the smaller number is always first.
+      # The number may be Infinity or -Infinity.
+      def range
+        [@from, @to]
+      end
 
-        def ==(o)
-          self.class == o.class && from == o.from && to == o.to
+      # Returns Enumerator if no block is given
+      # Returns nil if size is infinity (does not yield)
+      def each
+        if block_given?
+          enumerable? ? @from.upto(@to) { |x| yield x } : nil
+        else
+          to_enum
         end
       end
+
+      # Returns a range where both to and from are positive numbers. Negative
+      # numbers are converted to zero
+      # @return [PIntegerType] a positive range
+      def to_size
+        @from >= 0 ? self : PIntegerType.new(0, @to < 0 ? 0 : @to)
+      end
+
+      DEFAULT = PIntegerType.new(-Float::INFINITY)
     end
 
+    # @api public
+    #
     class PFloatType < PNumericType
-      module ClassModule
-        def hash
-          [self.class, from, to].hash
-        end
+      def generalize
+        DEFAULT
+      end
+
+      def instance?(o)
+        o.is_a?(Float) && o >= numeric_from && o <= numeric_to
+      end
+
+      DEFAULT = PFloatType.new(-Float::INFINITY)
+    end
+
+    # @api public
+    #
+    class PCollectionType < PAnyType
+      attr_reader :element_type, :size_type
+
+      def initialize(element_type, size_type = nil)
+        @element_type = element_type
+        @size_type = size_type
+      end
 
-        def ==(o)
-          self.class == o.class && from == o.from && to == o.to
+      def generalize
+        @element_type.nil? ? DEFAULT : PCollectionType.new(element_type.generalize, nil)
+      end
+
+      def instance?(o)
+        assignable?(TypeCalculator.infer(o))
+      end
+
+      # Returns an array with from (min) size to (max) size
+      def size_range
+        (@size_type || DEFAULT_SIZE).range
+      end
+
+      def hash
+        @element_type.hash * 31 + @size_type.hash
+      end
+
+      def ==(o)
+        self.class == o.class && @element_type == o.element_type && @size_type == o.size_type
+      end
+
+
+      DEFAULT_SIZE = PIntegerType.new(0)
+      ZERO_SIZE = PIntegerType.new(0, 0)
+      DEFAULT = PCollectionType.new(nil)
+
+      protected
+
+      # @api private
+      #
+      def _assignable?(o)
+        case o
+          when PCollectionType
+            (@size_type || DEFAULT_SIZE).assignable?(o.size_type || DEFAULT_SIZE)
+          when PTupleType
+            # compute the tuple's min/max size, and check if that size matches
+            from, to = type_to_range(o.size_type)
+            from = o.types.size - 1 + from
+            to = o.types.size - 1 + to
+            (@size_type || DEFAULT_SIZE).assignable?(PIntegerType.new(from, to))
+          when PStructType
+            from = to = o.elements.size
+            (@size_type || DEFAULT_SIZE).assignable?(PIntegerType.new(from, to))
+          else
+            false
         end
       end
     end
 
+    # @api public
+    #
     class PStringType < PScalarType
-      module ClassModule
+      attr_reader :size_type, :values
 
-        def hash
-          [self.class, self.size_type, Set.new(self.values)].hash
+      def generalize
+        DEFAULT
+      end
+
+      def initialize(size_type, values = [])
+        @size_type = size_type
+        @values = values.sort.freeze
+      end
+
+      def hash
+        @size_type.hash * 31 + @values.hash
+      end
+
+      def ==(o)
+        self.class == o.class && @size_type == o.size_type && @values == o.values
+      end
+
+      def instance?(o)
+        # true if size compliant
+        if o.is_a?(String) && (@size_type.nil? || @size_type.instance?(o.size))
+          @values.empty? || @values.include?(o)
+        else
+          false
         end
+      end
 
-        def ==(o)
-          self.class == o.class && self.size_type == o.size_type && Set.new(values) == Set.new(o.values)
+      DEFAULT = PStringType.new(nil)
+      NON_EMPTY = PStringType.new(PIntegerType.new(1))
+
+      protected
+
+      # @api private
+      def _assignable?(o)
+        if values.empty?
+          # A general string is assignable by any other string or pattern restricted string
+          # if the string has a size constraint it does not match since there is no reasonable way
+          # to compute the min/max length a pattern will match. For enum, it is possible to test that
+          # each enumerator value is within range
+          case o
+            when PStringType
+              # true if size compliant
+              (@size_type || PCollectionType::DEFAULT_SIZE).assignable?(o.size_type || PCollectionType::DEFAULT_SIZE)
+
+            when PPatternType
+              # true if size constraint is at least 0 to +Infinity (which is the same as the default)
+              @size_type.nil? || @size_type.assignable?(PCollectionType::DEFAULT_SIZE)
+
+            when PEnumType
+              if o.values.empty?
+                # enum represents all enums, and thus all strings, a sized constrained string can thus not
+                # be assigned any enum (unless it is max size).
+                @size_type.nil? || @size_type.assignable?(PCollectionType::DEFAULT_SIZE)
+              else
+                # true if all enum values are within range
+                orange = o.values.map(&:size).minmax
+                srange = (@size_type || PCollectionType::DEFAULT_SIZE).range
+                # If o min and max are within the range of t
+                srange[0] <= orange[0] && srange[1] >= orange[1]
+              end
+            else
+              # no other type matches string
+              false
+          end
+        elsif o.is_a?(PStringType)
+          # A specific string acts as a set of strings - must have exactly the same strings
+          # In this case, size does not matter since the definition is very precise anyway
+          values == o.values
+        else
+          # All others are false, since no other type describes the same set of specific strings
+          false
         end
       end
     end
 
+    # @api public
+    #
     class PRegexpType < PScalarType
-      module ClassModule
-        def regexp_derived
-          pattern_or_blank = pattern || ''
-          @_regexp = Regexp.new(pattern_or_blank) unless @_regexp && @_regexp.source == pattern_or_blank
-          @_regexp
-        end
+      attr_reader :pattern
 
-        def hash
-          [self.class, pattern].hash
-        end
+      def initialize(pattern)
+        @pattern = pattern
+      end
 
-        def ==(o)
-          self.class == o.class && pattern == o.pattern
-        end
+      def regexp
+        @regexp ||= Regexp.new(@pattern || '')
+      end
+
+      def hash
+        @pattern.hash
+      end
+
+      def ==(o)
+        self.class == o.class && @pattern == o.pattern
+      end
+
+      DEFAULT = PRegexpType.new(nil)
+
+      protected
+
+      # @api private
+      #
+      def _assignable?(o)
+        o.is_a?(PRegexpType) && (@pattern.nil? || @pattern == o.pattern)
       end
     end
 
+    # Represents a subtype of String that narrows the string to those matching the patterns
+    # If specified without a pattern it is basically the same as the String type.
+    #
+    # @api public
+    #
     class PPatternType < PScalarType
-      module ClassModule
+      attr_reader :patterns
 
-        def hash
-          [self.class, Set.new(patterns)].hash
-        end
+      def initialize(patterns)
+        @patterns = patterns.freeze
+      end
 
-        def ==(o)
-          self.class == o.class && Set.new(patterns) == Set.new(o.patterns)
-        end
+      def hash
+        @patterns.hash
       end
-    end
 
-    class PCollectionType < PAnyType
-      module ClassModule
-        # Returns an array with from (min) size to (max) size
-        def size_range
-          return [0, Float::INFINITY] if size_type.nil?
-          f = size_type.from || 0
-          t = size_type.to || Float::INFINITY
-          if f < t
-            [f, t]
+      def ==(o)
+        self.class == o.class && (@patterns | o.patterns).size == @patterns.size
+      end
+
+      DEFAULT = PPatternType.new([])
+
+      protected
+
+      # @api private
+      #
+      def _assignable?(o)
+        return true if self == o
+        case o
+        when PStringType, PEnumType
+          if o.values.empty?
+            # Strings / Enums (unknown which ones) cannot all match a pattern, but if there is no pattern it is ok
+            # (There should really always be a pattern, but better safe than sorry).
+            @patterns.empty?
           else
-            [t,f]
+            # all strings in String/Enum type must match one of the patterns in Pattern type,
+            # or Pattern represents all Patterns == all Strings
+            regexps = @patterns.map { |p| p.regexp }
+            regexps.empty? || o.values.all? { |v| regexps.any? {|re| re.match(v) } }
           end
+        when PPatternType
+          @patterns.empty?
+        else
+          false
         end
+      end
+    end
 
-        def hash
-          [self.class, element_type, size_type].hash
-        end
+    # @api public
+    #
+    class PBooleanType < PScalarType
 
-        def ==(o)
-          self.class == o.class && element_type == o.element_type && size_type == o.size_type
-        end
+      def instance?(o)
+        o == true || o == false
       end
-    end
 
-    class PStructElement < TypeModelObject
-      module ClassModule
-        def hash
-          [self.class, value_type, key_type].hash
-        end
+      DEFAULT = PBooleanType.new
 
-        def name
-          k = key_type
-          k = k.optional_type if k.is_a?(POptionalType)
-          k.values[0]
-        end
+      protected
 
-        def ==(o)
-          self.class == o.class && value_type == o.value_type && key_type == o.key_type
-        end
+      # @api private
+      #
+      def _assignable?(o)
+        o.is_a?(PBooleanType)
       end
     end
 
+    # @api public
+    #
+    # @api public
+    #
+    class PStructElement < TypedModelObject
+      attr_accessor :key_type, :value_type
+
+      def hash
+        value_type.hash * 31 + key_type.hash
+      end
+
+      def name
+        k = key_type
+        k = k.optional_type if k.is_a?(POptionalType)
+        k.values[0]
+      end
+
+      def initialize(key_type, value_type)
+        @key_type = key_type
+        @value_type = value_type
+      end
+
+      def generalize
+        PStructElement.new(@key_type, @value_type.generalize)
+      end
+
+      def <=>(o)
+        self.name <=> o.name
+      end
+
+      def ==(o)
+         self.class == o.class && value_type == o.value_type && key_type == o.key_type
+      end
+    end
 
+    # @api public
+    #
     class PStructType < PAnyType
-      module ClassModule
-        def hashed_elements_derived
-          @_hashed ||= elements.reduce({}) {|memo, e| memo[e.name] = e; memo }
-          @_hashed
-        end
+      include Enumerable
 
-        def clear_hashed_elements
-          @_hashed = nil
-        end
+      def initialize(elements)
+        @elements = elements.sort.freeze
+      end
 
-        def hash
-          [self.class, Set.new(elements)].hash
+      def each
+        if block_given?
+          elements.each { |elem| yield elem }
+        else
+          elements.to_enum
         end
+      end
 
-        def ==(o)
-          self.class == o.class && hashed_elements == o.hashed_elements
+      def generalize
+        @elements.empty? ? DEFAULT : PStructType.new(@elements.map { |se| se.generalize })
+      end
+
+      def hashed_elements
+        @hashed ||= @elements.reduce({}) {|memo, e| memo[e.name] = e; memo }
+      end
+ 
+      def hash
+        @elements.hash
+      end
+
+      def ==(o)
+        self.class == o.class && @elements == o.elements
+      end
+
+      def elements
+        @elements
+      end
+
+      def instance?(o)
+        return false unless o.is_a?(Hash)
+        matched = 0
+        @elements.all? do |e|
+          key = e.name
+          v = o[key]
+          if v.nil? && !o.include?(key)
+            # Entry is missing. Only OK when key is optional
+            e.key_type.assignable?(PUndefType::DEFAULT)
+          else
+            matched += 1
+            e.value_type.instance?(v)
+          end
+        end && matched == o.size
+      end
+
+      DEFAULT = PStructType.new([])
+
+      protected
+
+      # @api private
+      def _assignable?(o)
+        if o.is_a?(Types::PStructType)
+          h2 = o.hashed_elements
+          matched = 0
+          elements.all? do |e1|
+            e2 = h2[e1.name]
+            if e2.nil?
+              e1.key_type.assignable?(PUndefType::DEFAULT)
+            else
+              matched += 1
+              e1.key_type.assignable?(e2.key_type) && e1.value_type.assignable?(e2.value_type)
+            end
+          end && matched == h2.size
+        elsif o.is_a?(Types::PHashType)
+          required = 0
+          required_elements_assignable = elements.all? do |e|
+            if e.key_type.assignable?(PUndefType::DEFAULT)
+              true
+            else
+              required += 1
+              e.value_type.assignable?(o.element_type)
+            end
+          end
+          if required_elements_assignable
+            size_o = o.size_type || collection_default_size_t
+            PIntegerType.new(required, elements.size).assignable?(size_o)
+          end
+        else
+          false
         end
       end
     end
 
+    # @api public
+    #
     class PTupleType < PAnyType
-      module ClassModule
-        # Returns the number of elements accepted [min, max] in the tuple
-        def size_range
-          types_size = types.size
-          size_type.nil? ? [types_size, types_size] : size_type.range
-        end
-
-        # Returns the number of accepted occurrences [min, max] of the last type in the tuple
-        # The defaults is [1,1]
-        #
-        def repeat_last_range
-          types_size = types.size
-          if size_type.nil?
-            return [1, 1]
+      include Enumerable
+
+      # If set, describes min and max required of the given types - if max > size of
+      # types, the last type entry repeats
+      #
+      attr_reader :size_type
+
+      attr_reader :types
+
+      # @api private
+      def callable_args?(callable_t)
+        unless size_type.nil?
+          raise ArgumentError, 'Callable tuple may not have a size constraint when used as args'
+        end
+
+        params_tuple = callable_t.param_types
+        param_block_t = callable_t.block_type
+        arg_types = @types
+        arg_block_t = arg_types.last
+        if arg_block_t.kind_of_callable?
+          # Can't pass a block to a callable that doesn't accept one
+          return false if param_block_t.nil?
+
+          # Check that the block is of the right tyṕe
+          return false unless param_block_t.assignable?(arg_block_t)
+
+          # Check other arguments
+          arg_count = arg_types.size - 1
+          params_size_t = params_tuple.size_type || PIntegerType.new(*params_tuple.size_range)
+          return false unless params_size_t.assignable?(PIntegerType.new(arg_count, arg_count))
+
+          ctypes = params_tuple.types
+          arg_count.times do |index|
+            return false unless (ctypes[index] || ctypes[-1]).assignable?(arg_types[index])
           end
-          from, to = size_type.range()
-          min = from - (types_size-1)
-          min = min <= 0 ? 0 : min
-          max = to - (types_size-1)
-          [min, max]
+          return true
         end
 
-        def hash
-          [self.class, size_type, Set.new(types)].hash
+        # Check that tuple is assignable and that the block (if declared) is optional
+        params_tuple.assignable?(self) && (param_block_t.nil? || param_block_t.assignable?(PUndefType::DEFAULT))
+      end
+
+      def initialize(types, size_type = nil)
+        @types = types
+        @size_type = size_type.nil? ? nil : size_type.to_size
+      end
+
+      # Returns Enumerator for the types if no block is given, otherwise, calls the given
+      # block with each of the types in this tuple
+      def each
+        if block_given?
+          types.each { |x| yield x }
+        else
+          types.to_enum
         end
+      end
 
-        def ==(o)
-          self.class == o.class && types == o.types && size_type == o.size_type
+      def generalize
+        self == DEFAULT ? self : PTupleType.new(@types.map {|t| t.generalize })
+      end
+
+      def instance?(o)
+        return false unless o.is_a?(Array)
+        # compute the tuple's min/max size, and check if that size matches
+        size_t = size_type || PIntegerType.new(*size_range)
+
+        return false unless size_t.instance?(o.size)
+        o.each_with_index do |element, index|
+          return false unless (types[index] || types[-1]).instance?(element)
         end
+        true
       end
-    end
 
-    class PCallableType < PAnyType
-      module ClassModule
-        # Returns the number of accepted arguments [min, max]
-        def size_range
-          param_types.size_range
-        end
-
-        # Returns the number of accepted arguments for the last parameter type [min, max]
-        #
-        def last_range
-          param_types.repeat_last_range
-        end
-
-        # Range [0,0], [0,1], or [1,1] for the block
-        #
-        def block_range
-          case block_type
-          when Puppet::Pops::Types::POptionalType
-            [0,1]
-          when Puppet::Pops::Types::PVariantType, Puppet::Pops::Types::PCallableType
-            [1,1]
+      # Returns the number of elements accepted [min, max] in the tuple
+      def size_range
+        if @size_type.nil?
+          types_size = @types.size
+          [types_size, types_size]
+        else
+          @size_type.range
+        end
+      end
+
+      # Returns the number of accepted occurrences [min, max] of the last type in the tuple
+      # The defaults is [1,1]
+      #
+      def repeat_last_range
+        if @size_type.nil?
+          return [1, 1]
+        end
+        types_size = @types.size
+        from, to = @size_type.range
+        min = from - (types_size-1)
+        min = min <= 0 ? 0 : min
+        max = to - (types_size-1)
+        [min, max]
+      end
+
+      def hash
+        @size_type.hash * 31 + @types.hash
+      end
+
+      def ==(o)
+        self.class == o.class && @types == o.types && @size_type == o.size_type
+      end
+
+      DATA = PTupleType.new([PDataType::DEFAULT], PCollectionType::DEFAULT_SIZE)
+      DEFAULT = PTupleType.new([])
+
+      protected
+
+      # @api private
+      def _assignable?(o)
+        return true if self == o
+        s_types = types
+        return true if s_types.empty? && (o.is_a?(PArrayType))
+        size_s = size_type || PIntegerType.new(*size_range)
+
+        if o.is_a?(PTupleType)
+          size_o = o.size_type || PIntegerType.new(*o.size_range)
+
+          # not assignable if the number of types in o is outside number of types in t1
+          if size_s.assignable?(size_o)
+            o_types = o.types
+            o_types.size.times do |index|
+              return false unless (s_types[index] || s_types[-1]).assignable?(o_types[index])
+            end
+            return true
           else
-            [0,0]
+            return false
           end
+        elsif o.is_a?(PArrayType)
+          o_entry = o.element_type
+          # Array of anything can not be assigned (unless tuple is tuple of anything) - this case
+          # was handled at the top of this method.
+          #
+          return false if o_entry.nil?
+          size_o = o.size_type || PCollectionType::DEFAULT_SIZE
+          return false unless size_s.assignable?(size_o)
+          [s_types.size, size_o.range[1]].min.times { |index| return false unless (s_types[index] || s_types[-1]).assignable?(o_entry) }
+          true
+        else
+          false
         end
+      end
+    end
 
-        def hash
-          [self.class, Set.new(param_types), block_type].hash
-        end
+    # @api public
+    #
+    class PCallableType < PAnyType
+      # Types of parameters as a Tuple with required/optional count, or an Integer with min (required), max count
+      # @return [PTupleType] the tuple representing the parameter types
+      attr_reader :param_types
+
+      # Although being an abstract type reference, only Callable, or all Callables wrapped in
+      # Optional or Variant are supported
+      # If not set, the meaning is that block is not supported.
+      # @return [PAnyType|nil] the block type
+      attr_reader :block_type
+
+      # @param param_types [PTupleType]
+      # @param block_type [PAnyType|nil]
+      def initialize(param_types, block_type = nil)
+        @param_types = param_types
+        @block_type = block_type
+      end
 
-        def ==(o)
-          self.class == o.class && param_types == o.param_types && block_type == o.block_type
+      def generalize
+        return self if self == DEFAULT
+        params_t = @param_types.nil? ? nil : @param_types.generalize
+        block_t = @block_type.nil? ? nil : @block_type.generalize
+        PCallableType.new(params_t, block_t)
+      end
+
+      def instance?(o)
+        assignable?(TypeCalculator.infer(o))
+      end
+
+      # @api private
+      def callable_args?(required_callable_t)
+        # If the required callable is euqal or more specific than self, self is acceptable arguments
+        required_callable_t.assignable?(self)
+      end
+
+      def kind_of_callable?(optional=true)
+          true
+      end
+
+      # Returns the number of accepted arguments [min, max]
+      def size_range
+        @param_types.nil? ? nil : @param_types.size_range
+      end
+
+      # Returns the number of accepted arguments for the last parameter type [min, max]
+      #
+      def last_range
+        @param_types.nil? ? nil : @param_types.repeat_last_range
+      end
+
+      # Range [0,0], [0,1], or [1,1] for the block
+      #
+      def block_range
+        case block_type
+        when POptionalType
+          [0,1]
+        when PVariantType, PCallableType
+          [1,1]
+        else
+          [0,0]
         end
       end
+
+      def hash
+        @param_types.hash * 31 + @block_type.hash
+      end
+
+      def ==(o)
+        self.class == o.class && @param_types == o.param_types && @block_type == o.block_type
+      end
+
+      DEFAULT = PCallableType.new(nil)
+
+      protected
+
+      # @api private
+      def _assignable?(o)
+        return false unless o.is_a?(PCallableType)
+        # nil param_types means, any other Callable is assignable
+        return true if @param_types.nil?
+
+        # NOTE: these tests are made in reverse as it is calling the callable that is constrained
+        # (it's lower bound), not its upper bound
+        return false unless o.param_types.assignable?(@param_types)
+        # names are ignored, they are just information
+        # Blocks must be compatible
+        this_block_t = @block_type || PUndefType::DEFAULT
+        that_block_t = o.block_type || PUndefType::DEFAULT
+        that_block_t.assignable?(this_block_t)
+      end
     end
 
+    # @api public
+    #
     class PArrayType < PCollectionType
-      module ClassModule
-        def hash
-          [self.class, self.element_type, self.size_type].hash
+
+      # @api private
+      def callable_args?(callable)
+        param_t = callable.param_types
+        block_t = callable.block_type
+        # does not support calling with a block, but have to check that callable is ok with missing block
+        (param_t.nil? || param_t.assignable?(self)) && (block_t.nil? || block_t.assignable(PUndefType::DEFAULT))
+      end
+
+      def generalize
+        if self == DEFAULT
+          self
+        else
+          PArrayType.new(element_type.nil? ? nil : element_type.generalize)
         end
+      end
 
-        def ==(o)
-          self.class == o.class && self.element_type == o.element_type && self.size_type == o.size_type
+      def instance?(o)
+        return false unless o.is_a?(Array)
+        element_t = element_type
+        return false unless element_t.nil? || o.all? {|element| element_t.instance?(element) }
+        size_t = size_type
+        size_t.nil? || size_t.instance?(o.size)
+      end
+
+      DATA = PArrayType.new(PDataType::DEFAULT, PCollectionType::DEFAULT_SIZE)
+      DEFAULT = PArrayType.new(nil)
+      EMPTY = PArrayType.new(PUnitType::DEFAULT, PCollectionType::ZERO_SIZE)
+
+      protected
+
+      # Array is assignable if o is an Array and o's element type is assignable, or if o is a Tuple
+      # @api private
+      def _assignable?(o)
+        s_entry = element_type
+        if o.is_a?(PTupleType)
+
+          # Tuple of anything can not be assigned (unless array is tuple of anything) - this case
+          # was handled at the top of this method.
+          #
+          return false if s_entry.nil?
+
+          return false unless o.types.all? {|o_element_t| s_entry.assignable?(o_element_t) }
+          o_regular = o.types[0..-2]
+          o_ranged = o.types[-1]
+          o_from, o_to = type_to_range(o.size_type)
+          o_required = o_regular.size + o_from
+
+          # array type may be size constrained
+          size_s = size_type || DEFAULT_SIZE
+          min, max = size_s.range
+          # Tuple with fewer min entries can not be assigned
+          return false if o_required < min
+          # Tuple with more optionally available entries can not be assigned
+          return false if o_regular.size + o_to > max
+          # each tuple type must be assignable to the element type
+          o_required.times do |index|
+            o_entry = tuple_entry_at(o, o_from, o_to, index)
+            return false unless s_entry.assignable?(o_entry)
+          end
+          # ... and so must the last, possibly optional (ranged) type
+          s_entry.assignable?(o_ranged)
+        elsif o.is_a?(PArrayType)
+          super && (s_entry.nil? || s_entry.assignable?(o.element_type))
+        else
+          false
         end
       end
     end
 
+    # @api public
+    #
     class PHashType < PCollectionType
-      module ClassModule
-        def hash
-          [self.class, key_type, self.element_type, self.size_type].hash
+      attr_accessor :key_type
+
+      def initialize(key_type, value_type, size_type = nil)
+        super(value_type, size_type)
+        @key_type = key_type
+      end
+
+      def generalize
+        if self == DEFAULT || self == EMPTY
+          self
+        else
+          key_t = @key_type
+          key_t = key_t.generalize unless key_t.nil?
+          value_t = element_type
+          value_t = value_t.generalize unless value_t.nil?
+          PHashType.new(key_t, value_t)
         end
+      end
 
-        def ==(o)
-          self.class        == o.class         &&
-          key_type          == o.key_type      &&
-          self.element_type == o.element_type  &&
-          self.size_type    == o.size_type
+      def hash
+        @key_type.hash * 31 + super
+      end
+
+      def instance?(o)
+        return false unless o.is_a?(Hash)
+        key_t = key_type
+        element_t = element_type
+        if (key_t.nil? || o.keys.all? {|key| key_t.instance?(key) }) &&
+            (element_t.nil? || o.values.all? {|value| element_t.instance?(value) })
+          size_t = size_type
+          size_t.nil? || size_t.instance?(o.size)
+        else
+          false
         end
+      end
+
+      def ==(o)
+        super && @key_type == o.key_type
+      end
+
+      def is_the_empty_hash?
+        self == EMPTY
+      end
 
-        def is_the_empty_hash?
-          size_type.is_a?(PIntegerType) && size_type.from == 0 && size_type.to == 0 && key_type.is_a?(PUndefType) && element_type.is_a?(PUndefType)
+      DEFAULT = PHashType.new(nil, nil)
+      DATA = PHashType.new(PScalarType::DEFAULT, PDataType::DEFAULT, DEFAULT_SIZE)
+      EMPTY = PHashType.new(PUndefType::DEFAULT, PUndefType::DEFAULT, PIntegerType.new(0, 0))
+
+      protected
+
+      # Hash is assignable if o is a Hash and o's key and element types are assignable
+      # @api private
+      def _assignable?(o)
+        case o
+          when PHashType
+            size_s = size_type
+            return true if (size_s.nil? || size_s.from == 0) && o.is_the_empty_hash?
+            return false unless (key_type.nil? || key_type.assignable?(o.key_type)) && (element_type.nil? || element_type.assignable?(o.element_type))
+            super
+          when PStructType
+            # hash must accept String as key type
+            # hash must accept all value types
+            # hash must accept the size of the struct
+            o_elements = o.elements
+            (size_type || DEFAULT_SIZE).instance?(o_elements.size) &&
+                o_elements.all? {|e| (key_type.nil? || key_type.instance?(e.name)) && (element_type.nil? || element_type.assignable?(e.value_type)) }
+          else
+            false
         end
       end
     end
 
-    class PRuntimeType < PAnyType
-      module ClassModule
-        def hash
-          [self.class, runtime, runtime_type_name].hash
+    # A flexible type describing an any? of other types
+    # @api public
+    #
+    class PVariantType < PAnyType
+      include Enumerable
+
+      attr_reader :types
+
+      def initialize(types)
+        @types = types.freeze
+      end
+
+      def each
+        if block_given?
+          types.each { |t| yield t }
+        else
+          types.to_enum
         end
+      end
+
+      def generalize
+        (self == DEFAULT || self == DATA) ? self : PVariantType.new(@types.map {|t| t.generalize})
+      end
+
+      def hash
+        @types.hash
+      end
+
+      def instance?(o)
+        # instance of variant if o is instance? of any of variant's types
+        @types.any? { |type| type.instance?(o) }
+      end
+
+      def kind_of_callable?(optional = true)
+        @types.all? { |type| type.kind_of_callable?(optional) }
+      end
+
+      def ==(o)
+        # TODO: This special case doesn't look like it belongs here
+        self.class == o.class && (@types | o.types).size == @types.size ||
+            o.class == PDataType && self == DATA
+      end
 
-        def ==(o)
-          self.class == o.class && runtime == o.runtime && runtime_type_name == o.runtime_type_name
+      # Variant compatible with the Data type.
+      DATA = PVariantType.new([PHashType::DATA, PArrayType::DATA, PScalarType::DEFAULT, PUndefType::DEFAULT, PTupleType::DATA])
+
+      DEFAULT = PVariantType.new([])
+
+      protected
+
+      # @api private
+      def _assignable?(o)
+        # Data is a specific variant
+        o = DATA if o.is_a?(PDataType)
+        if o.is_a?(PVariantType)
+          # A variant is assignable if all of its options are assignable to one of this type's options
+          return true if self == o
+          o.types.all? do |other|
+            # if the other is a Variant, all of its options, but be assignable to one of this type's options
+            other = other.is_a?(PDataType) ? DATA : other
+            if other.is_a?(PVariantType)
+              assignable?(other)
+            else
+              types.any? {|option_t| option_t.assignable?(other) }
+            end
+          end
+        else
+          # A variant is assignable if o is assignable to any of its types
+          types.any? { |option_t| option_t.assignable?(o) }
         end
       end
     end
 
+    # @api public
+    #
+    class PRuntimeType < PAnyType
+      attr_reader :runtime, :runtime_type_name
+
+      def initialize(runtime, runtime_type_name = nil)
+        @runtime = runtime
+        @runtime_type_name = runtime_type_name
+      end
+
+      def hash
+        @runtime.hash * 31 + @runtime_type_name.hash
+      end
+
+      def ==(o)
+        self.class == o.class && @runtime == o.runtime && @runtime_type_name == o.runtime_type_name
+      end
+
+      def instance?(o)
+        assignable?(TypeCalculator.infer(o))
+      end
+
+      DEFAULT = PRuntimeType.new(nil)
+
+      protected
+
+      # Assignable if o's has the same runtime and the runtime name resolves to
+      # a class that is the same or subclass of t1's resolved runtime type name
+      # @api private
+      def _assignable?(o)
+        return false unless o.is_a?(PRuntimeType)
+        return false unless @runtime == o.runtime
+        return true if @runtime_type_name.nil?   # t1 is wider
+        return false if o.runtime_type_name.nil?  # t1 not nil, so o can not be wider
+
+        # NOTE: This only supports Ruby, must change when/if the set of runtimes is expanded
+        c1 = class_from_string(@runtime_type_name)
+        c2 = class_from_string(o.runtime_type_name)
+        return false unless c1.is_a?(Module) && c2.is_a?(Module)
+        !!(c2 <= c1)
+      end
+    end
+
+    # Abstract representation of a type that can be placed in a Catalog.
+    # @api public
+    #
+    class PCatalogEntryType < PAnyType
+
+      DEFAULT = PCatalogEntryType.new
+
+      def instance?(o)
+        assignable?(TypeCalculator.infer(o))
+      end
+
+      protected
+      # @api private
+      def _assignable?(o)
+        o.is_a?(PCatalogEntryType)
+      end
+    end
+
+    # Represents a (host-) class in the Puppet Language.
+    # @api public
+    #
     class PHostClassType < PCatalogEntryType
-      module ClassModule
-        def hash
-          [self.class, class_name].hash
-        end
-        def ==(o)
-          self.class == o.class && class_name == o.class_name
-        end
+      attr_reader :class_name
+
+      def initialize(class_name)
+        @class_name = class_name
+      end
+
+      def hash
+        11 * @class_name.hash
+      end
+      def ==(o)
+        self.class == o.class && @class_name == o.class_name
+      end
+
+      DEFAULT = PHostClassType.new(nil)
+
+      protected
+
+      # @api private
+      def _assignable?(o)
+        return false unless o.is_a?(PHostClassType)
+        # Class = Class[name}, Class[name] != Class
+        return true if @class_name.nil?
+        # Class[name] = Class[name]
+        @class_name == o.class_name
       end
     end
 
+    # Represents a Resource Type in the Puppet Language
+    # @api public
+    #
     class PResourceType < PCatalogEntryType
-      module ClassModule
-        def hash
-          [self.class, type_name, title].hash
-        end
-        def ==(o)
-          self.class == o.class && type_name == o.type_name && title == o.title
-        end
+      attr_reader :type_name, :title
+
+      def initialize(type_name, title = nil)
+        @type_name = type_name
+        @title = title
+      end
+
+      def hash
+        @type_name.hash * 31 + @title.hash
+      end
+
+      def ==(o)
+        self.class == o.class && @type_name == o.type_name && @title == o.title
+      end
+
+      DEFAULT = PResourceType.new(nil)
+
+      protected
+
+      # @api private
+      def _assignable?(o)
+        return false unless o.is_a?(PResourceType)
+        return true if @type_name.nil?
+        return false if @type_name != o.type_name
+        return true if @title.nil?
+        @title == o.title
       end
     end
 
+    # Represents a type that accept PUndefType instead of the type parameter
+    # required_type - is a short hand for Variant[T, Undef]
+    # @api public
+    #
     class POptionalType < PAnyType
-      module ClassModule
-        def hash
-          [self.class, optional_type].hash
-        end
+      attr_reader :optional_type
+
+      def initialize(optional_type)
+        @optional_type = optional_type
+      end
+
+      def generalize
+        @optional_type.nil? ? self : PType.new(@optional_type.generalize)
+      end
+
+      def hash
+        7 * @optional_type.hash
+      end
+
+      def kind_of_callable?(optional=true)
+          optional && !@optional_type.nil? && @optional_type.kind_of_callable?(optional)
+      end
+
+      def ==(o)
+        self.class == o.class && @optional_type == o.optional_type
+      end
+
+      def instance?(o)
+        PUndefType::DEFAULT.instance?(o) || (!optional_type.nil? && optional_type.instance?(o))
+      end
 
-        def ==(o)
-          self.class == o.class && optional_type == o.optional_type
+      DEFAULT = POptionalType.new(nil)
+
+      protected
+
+      # @api private
+      def _assignable?(o)
+        return true if o.is_a?(PUndefType)
+        return true if @optional_type.nil?
+        if o.is_a?(POptionalType)
+          @optional_type.assignable?(o.optional_type)
+        else
+          @optional_type.assignable?(o)
         end
       end
     end
   end
 end
+