diff --git a/lib/puppet/functions.rb b/lib/puppet/functions.rb
index de136e7e6..7146a4761 100644
--- a/lib/puppet/functions.rb
+++ b/lib/puppet/functions.rb
@@ -1,548 +1,548 @@
 # @note WARNING: This new function API is still under development and may change at any time
 #
 # Functions in the puppet language can be written in Ruby and distributed in
 # puppet modules. The function is written by creating a file in the module's
 # `lib/puppet/functions/<modulename>` directory, where `<modulename>` is
 # replaced with the module's name. The file should have the name of the function.
 # For example, to create a function named `min` in a module named `math` create
 # a file named `lib/puppet/functions/math/min.rb` in the module.
 #
 # A function is implemented by calling {Puppet::Functions.create_function}, and
 # passing it a block that defines the implementation of the function.
 #
 # Functions are namespaced inside the module that contains them. The name of
 # the function is prefixed with the name of the module. For example,
 # `math::min`.
 #
 # @example A simple function
 #   Puppet::Functions.create_function('math::min') do
 #     def min(a, b)
 #       a <= b ? a : b
 #     end
 #   end
 #
 # Anatomy of a function
 # ---
 #
 # Functions are composed of four parts: the name, the implementation methods,
 # the signatures, and the dispatches.
 #
 # The name is the string given to the {Puppet::Functions.create_function}
 # method. It specifies the name to use when calling the function in the puppet
 # language, or from other functions.
 #
 # The implementation methods are ruby methods (there can be one or more) that
 # provide that actual implementation of the function's behavior. In the
 # simplest case the name of the function (excluding any namespace) and the name
 # of the method are the same. When that is done no other parts (signatures and
 # dispatches) need to be used.
 #
 # Signatures are a way of specifying the types of the function's parameters.
 # The types of any arguments will be checked against the types declared in the
 # signature and an error will be produced if they don't match. The types are
 # defined by using the same syntax for types as in the puppet language.
 #
 # Dispatches are how signatures and implementation methods are tied together.
 # When the function is called, puppet searches the signatures for one that
 # matches the supplied arguments. Each signature is part of a dispatch, which
 # specifies the method that should be called for that signature. When a
 # matching signature is found, the corrosponding method is called.
 #
 # Documentation for the function should be placed as comments to the
 # implementation method(s).
 #
 # @todo Documentation for individual instances of these new functions is not
 #   yet tied into the puppet doc system.
 #
 # @example Dispatching to different methods by type
 #   Puppet::Functions.create_function('math::min') do
 #     dispatch :numeric_min do
 #       param 'Numeric', 'a'
 #       param 'Numeric', 'b'
 #     end
 #
 #     dispatch :string_min do
 #       param 'String', 'a'
 #       param 'String', 'b'
 #     end
 #
 #     def numeric_min(a, b)
 #       a <= b ? a : b
 #     end
 #
 #     def string_min(a, b)
 #       a.downcase <= b.downcase ? a : b
 #     end
 #   end
 #
 # Specifying Signatures
 # ---
 #
 # If nothing is specified, the number of arguments given to the function must
 # be the same as the number of parameters, and all of the parameters are of
 # type 'Any'.
 #
 # To express that the last parameter captures the rest, the method
 # `last_captures_rest` can be called. This indicates that the last parameter is
 # a varargs parameter and will be passed to the implementing method as an array
 # of the given type.
 #
 # When defining a dispatch for a function, the resulting dispatch matches
 # against the specified argument types and min/max occurrence of optional
 # entries. When the dispatch makes the call to the implementation method the
 # arguments are simply passed and it is the responsibility of the method's
 # implementor to ensure it can handle those arguments (i.e. there is no check
 # that what was declared as optional actually has a default value, and that
 # a "captures rest" is declared using a `*`).
 #
 # @example Varargs
 #   Puppet::Functions.create_function('foo') do
 #     dispatch :foo do
 #       param 'Numeric', 'first'
 #       param 'Numeric', 'values'
 #       last_captures_rest
 #     end
 #
 #     def foo(first, *values)
 #       # do something
 #     end
 #   end
 #
 # Access to Scope
 # ---
 # In general, functions should not need access to scope; they should be
 # written to act on their given input only. If they absolutely must look up
 # variable values, they should do so via the closure scope (the scope where
 # they are defined) - this is done by calling `closure_scope()`.
 #
 # Calling other Functions
 # ---
 # Calling other functions by name is directly supported via
 # {Puppet::Pops::Functions::Function#call_function}. This allows a function to
 # call other functions visible from its loader.
 #
 # @api public
 module Puppet::Functions
   # @param func_name [String, Symbol] a simple or qualified function name
   # @param block [Proc] the block that defines the methods and dispatch of the
   #   Function to create
   # @return [Class<Function>] the newly created Function class
   #
   # @api public
   def self.create_function(func_name, function_base = Function, &block)
     if function_base.ancestors.none? { |s| s == Puppet::Pops::Functions::Function }
       raise ArgumentError, "Functions must be based on Puppet::Pops::Functions::Function. Got #{function_base}"
     end
 
     func_name = func_name.to_s
     # Creates an anonymous class to represent the function
     # The idea being that it is garbage collected when there are no more
     # references to it.
     #
     the_class = Class.new(function_base, &block)
 
     # Make the anonymous class appear to have the class-name <func_name>
     # Even if this class is not bound to such a symbol in a global ruby scope and
     # must be resolved via the loader.
     # This also overrides any attempt to define a name method in the given block
     # (Since it redefines it)
     #
     # TODO, enforce name in lower case (to further make it stand out since Ruby
     # class names are upper case)
     #
     the_class.instance_eval do
       @func_name = func_name
       def name
         @func_name
       end
     end
 
     # Automatically create an object dispatcher based on introspection if the
     # loaded user code did not define any dispatchers. Fail if function name
     # does not match a given method name in user code.
     #
     if the_class.dispatcher.empty?
       simple_name = func_name.split(/::/)[-1]
       type, names = default_dispatcher(the_class, simple_name)
       last_captures_rest = (type.size_range[1] == Puppet::Pops::Types::INFINITY)
       the_class.dispatcher.add_dispatch(type, simple_name, names, nil, nil, nil, last_captures_rest)
     end
 
     # The function class is returned as the result of the create function method
     the_class
   end
 
   # Creates a default dispatcher configured from a method with the same name as the function
   #
   # @api private
   def self.default_dispatcher(the_class, func_name)
     unless the_class.method_defined?(func_name)
       raise ArgumentError, "Function Creation Error, cannot create a default dispatcher for function '#{func_name}', no method with this name found"
     end
     any_signature(*min_max_param(the_class.instance_method(func_name)))
   end
 
   # @api private
   def self.min_max_param(method)
     # Ruby 1.8.7 does not have support for details about parameters
     if method.respond_to?(:parameters)
       result = {:req => 0, :opt => 0, :rest => 0 }
       # TODO: Optimize into one map iteration that produces names map, and sets
       # count as side effect
       method.parameters.each { |p| result[p[0]] += 1 }
       from = result[:req]
       to = result[:rest] > 0 ? :default : from + result[:opt]
       names = method.parameters.map {|p| p[1].to_s }
     else
       # Cannot correctly compute the signature in Ruby 1.8.7 because arity for
       # optional values is screwed up (there is no way to get the upper limit),
       # an optional looks the same as a varargs In this case - the failure will
       # simply come later when the call fails
       #
       arity = method.arity
       from = arity >= 0 ? arity : -arity -1
       to = arity >= 0 ? arity : :default  # i.e. infinite (which is wrong when there are optional - flaw in 1.8.7)
       names = [] # no names available
     end
     [from, to, names]
   end
 
   # Construct a signature consisting of Object type, with min, and max, and given names.
   # (there is only one type entry).
   #
   # @api private
   def self.any_signature(from, to, names)
     # Construct the type for the signature
     # Tuple[Object, from, to]
     factory = Puppet::Pops::Types::TypeFactory
     [factory.callable(factory.any, from, to), names]
   end
 
   # Function
   # ===
   # This class is the base class for all Puppet 4x Function API functions. A
   # specialized class is created for each puppet function.
   #
   # @api public
   class Function < Puppet::Pops::Functions::Function
 
     # @api private
     def self.builder
       @type_parser ||= Puppet::Pops::Types::TypeParser.new
       @all_callables ||= Puppet::Pops::Types::TypeFactory.all_callables
       DispatcherBuilder.new(dispatcher, @type_parser, @all_callables)
     end
 
     # Dispatch any calls that match the signature to the provided method name.
     #
     # @param meth_name [Symbol] The name of the implementation method to call
     #   when the signature defined in the block matches the arguments to a call
     #   to the function.
     # @return [Void]
     #
     # @api public
     def self.dispatch(meth_name, &block)
       builder().instance_eval do
         dispatch(meth_name, &block)
       end
     end
   end
 
   # Public api methods of the DispatcherBuilder are available within dispatch()
   # blocks declared in a Puppet::Function.create_function() call.
   #
   # @api public
   class DispatcherBuilder
     # @api private
     def initialize(dispatcher, type_parser, all_callables)
       @type_parser = type_parser
       @all_callables = all_callables
       @dispatcher = dispatcher
     end
 
     # Defines a positional parameter with type and name
     #
     # @param type [String] The type specification for the parameter.
     # @param name [String] The name of the parameter. This is primarily used
     #   for error message output and does not have to match the name of the
     #   parameter on the implementation method.
     # @return [Void]
     #
     # @api public
     def param(type, name)
       if type.is_a?(String)
         @types << type
         @names << name
         # mark what should be picked for this position when dispatching
         @weaving << @names.size()-1
       else
         raise ArgumentError, "Type signature argument must be a String reference to a Puppet Data Type. Got #{type.class}"
       end
     end
 
     # Defines one required block parameter that may appear last. If type and name is missing the
     # default type is "Callable", and the name is "block". If only one
     # parameter is given, then that is the name and the type is "Callable".
     #
     # @api public
     def required_block_param(*type_and_name)
       case type_and_name.size
       when 0
         type = @all_callables
         name = 'block'
       when 1
         type = @all_callables
         name = type_and_name[0]
       when 2
         type_string, name = type_and_name
         type = @type_parser.parse(type_string)
       else
         raise ArgumentError, "block_param accepts max 2 arguments (type, name), got #{type_and_name.size}."
       end
 
-      unless type.is_a?(Puppet::Pops::Types::PCallableType)
-        raise ArgumentError, "Expected PCallableType, got #{type.class}"
+      unless Puppet::Pops::Types::TypeCalculator.is_kind_of_callable?(type, false)
+        raise ArgumentError, "Expected PCallableType or PVariantType thereof, got #{type.class}"
       end
 
-      unless name.is_a?(String)
-        raise ArgumentError, "Expected block_param name to be a String, got #{name.class}"
+      unless name.is_a?(String) || name.is_a?(Symbol)
+        raise ArgumentError, "Expected block_param name to be a String or Symbol, got #{name.class}"
       end
 
       if @block_type.nil?
         @block_type = type
         @block_name = name
       else
         raise ArgumentError, "Attempt to redefine block"
       end
     end
 
     # Defines one optional block parameter that may appear last. If type or name is missing the
     # defaults are "any callable", and the name is "block". The implementor of the dispatch target
     # must use block = nil when it is optional (or an error is raised when the call is made).
     #
     # @api public
     def optional_block_param(*type_and_name)
       # same as required, only wrap the result in an optional type
       required_block_param(*type_and_name)
       @block_type = Puppet::Pops::Types::TypeFactory.optional(@block_type)
     end
 
     # Specifies the min and max occurance of arguments (of the specified types)
     # if something other than the exact count from the number of specified
     # types). The max value may be specified as -1 if an infinite number of
     # arguments are supported. When max is > than the number of specified
     # types, the last specified type repeats.
     #
     # @api public
     def arg_count(min_occurs, max_occurs)
       @min = min_occurs
       @max = max_occurs
       unless min_occurs.is_a?(Integer) && min_occurs >= 0
         raise ArgumentError, "min arg_count of function parameter must be an Integer >=0, got #{min_occurs.class} '#{min_occurs}'"
       end
       unless max_occurs == :default || (max_occurs.is_a?(Integer) && max_occurs >= 0)
         raise ArgumentError, "max arg_count of function parameter must be an Integer >= 0, or :default, got #{max_occurs.class} '#{max_occurs}'"
       end
       unless max_occurs == :default || (max_occurs.is_a?(Integer) && max_occurs >= min_occurs)
         raise ArgumentError, "max arg_count must be :default (infinite) or >= min arg_count, got min: '#{min_occurs}, max: '#{max_occurs}'"
       end
     end
 
     # Specifies that the last argument captures the rest.
     #
     # @api public
     def last_captures_rest
       @last_captures = true
     end
 
     private
 
     # @api private
     def dispatch(meth_name, &block)
       # an array of either an index into names/types, or an array with
       # injection information [type, name, injection_name] used when the call
       # is being made to weave injections into the given arguments.
       #
       @types = []
       @names = []
       @weaving = []
       @injections = []
       @min = nil
       @max = nil
       @last_captures = false
       @block_type = nil
       @block_name = nil
       self.instance_eval &block
       callable_t = create_callable(@types, @block_type, @min, @max)
       @dispatcher.add_dispatch(callable_t, meth_name, @names, @block_name, @injections, @weaving, @last_captures)
     end
 
     # Handles creation of a callable type from strings specifications of puppet
     # types and allows the min/max occurs of the given types to be given as one
     # or two integer values at the end.  The given block_type should be
     # Optional[Callable], Callable, or nil.
     #
     # @api private
     def create_callable(types, block_type, from, to)
       mapped_types = types.map do |t|
         @type_parser.parse(t)
       end
 
       if !(from.nil? && to.nil?)
         mapped_types << from
         mapped_types << to
       end
 
       if block_type
         mapped_types << block_type
       end
 
       Puppet::Pops::Types::TypeFactory.callable(*mapped_types)
     end
   end
 
   private
 
   # @note WARNING: This style of creating functions is not public. It is a system
   #   under development that will be used for creating "system" functions.
   #
   # This is a private, internal, system for creating functions. It supports
   # everything that the public function definition system supports as well as a
   # few extra features.
   #
   # Injection Support
   # ===
   # The Function API supports injection of data and services. It is possible to
   # make injection that takes effect when the function is loaded (for services
   # and runtime configuration that does not change depending on how/from where
   # in what context the function is called. It is also possible to inject and
   # weave argument values into a call.
   #
   # Injection of attributes
   # ---
   # Injection of attributes is performed by one of the methods `attr_injected`,
   # and `attr_injected_producer`.  The injected attributes are available via
   # accessor method calls.
   #
   # @example using injected attributes
   #   Puppet::Functions.create_function('test') do
   #     attr_injected String, :larger, 'message_larger'
   #     attr_injected String, :smaller, 'message_smaller'
   #     def test(a, b)
   #       a > b ? larger() : smaller()
   #     end
   #   end
   #
   # @api private
   class InternalFunction < Function
     # @api private
     def self.builder
       @type_parser ||= Puppet::Pops::Types::TypeParser.new
       @all_callables ||= Puppet::Pops::Types::TypeFactory.all_callables
       InternalDispatchBuilder.new(dispatcher, @type_parser, @all_callables)
     end
 
     # Defines class level injected attribute with reader method
     #
     # @api private
     def self.attr_injected(type, attribute_name, injection_name = nil)
       define_method(attribute_name) do
         ivar = :"@#{attribute_name.to_s}"
         unless instance_variable_defined?(ivar)
           injector = Puppet.lookup(:injector)
           instance_variable_set(ivar, injector.lookup(closure_scope, type, injection_name))
         end
         instance_variable_get(ivar)
       end
     end
 
     # Defines class level injected producer attribute with reader method
     #
     # @api private
     def self.attr_injected_producer(type, attribute_name, injection_name = nil)
       define_method(attribute_name) do
         ivar = :"@#{attribute_name.to_s}"
         unless instance_variable_defined?(ivar)
           injector = Puppet.lookup(:injector)
           instance_variable_set(ivar, injector.lookup_producer(closure_scope, type, injection_name))
         end
         instance_variable_get(ivar)
       end
     end
   end
 
   # @note WARNING: This style of creating functions is not public. It is a system
   #   under development that will be used for creating "system" functions.
   #
   # Injection and Weaving of parameters
   # ---
   # It is possible to inject and weave parameters into a call. These extra
   # parameters are not part of the parameters passed from the Puppet logic, and
   # they can not be overridden by parameters given as arguments in the call.
   # They are invisible to the Puppet Language.
   #
   # @example using injected parameters
   #   Puppet::Functions.create_function('test') do
   #     dispatch :test do
   #       param 'Scalar', 'a'
   #       param 'Scalar', 'b'
   #       injected_param 'String', 'larger', 'message_larger'
   #       injected_param 'String', 'smaller', 'message_smaller'
   #     end
   #     def test(a, b, larger, smaller)
   #       a > b ? larger : smaller
   #     end
   #   end
   #
   # The function in the example above is called like this:
   #
   #     test(10, 20)
   #
   # Using injected value as default
   # ---
   # Default value assignment is handled by using the regular Ruby mechanism (a
   # value is assigned to the variable).  The dispatch simply indicates that the
   # value is optional. If the default value should be injected, it can be
   # handled different ways depending on what is desired:
   #
   # * by calling the accessor method for an injected Function class attribute.
   #   This is suitable if the value is constant across all instantiations of the
   #   function, and across all calls.
   # * by injecting a parameter into the call
   #   to the left of the parameter, and then assigning that as the default value.
   # * One of the above forms, but using an injected producer instead of a
   #   directly injected value.
   #
   # @example method with injected default values
   #   Puppet::Functions.create_function('test') do
   #     dispatch :test do
   #       injected_param String, 'b_default', 'b_default_value_key'
   #       param 'Scalar', 'a'
   #       param 'Scalar', 'b'
   #     end
   #     def test(b_default, a, b = b_default)
   #       # ...
   #     end
   #   end
   #
   # @api private
   class InternalDispatchBuilder < DispatcherBuilder
     # TODO: is param name really needed? Perhaps for error messages? (it is unused now)
     #
     # @api private
     def injected_param(type, name, injection_name = '')
       @injections << [type, name, injection_name]
       # mark what should be picked for this position when dispatching
       @weaving << [@injections.size() -1]
     end
 
     # TODO: is param name really needed? Perhaps for error messages? (it is unused now)
     #
     # @api private
     def injected_producer_param(type, name, injection_name = '')
       @injections << [type, name, injection_name, :producer]
       # mark what should be picked for this position when dispatching
       @weaving << [@injections.size()-1]
     end
   end
 end
diff --git a/lib/puppet/pops/types/type_calculator.rb b/lib/puppet/pops/types/type_calculator.rb
index a62c86fda..2a0f8e263 100644
--- a/lib/puppet/pops/types/type_calculator.rb
+++ b/lib/puppet/pops/types/type_calculator.rb
@@ -1,1656 +1,1665 @@
 # The TypeCalculator can answer questions about puppet types.
 #
 # The Puppet type system is primarily based on sub-classing. When asking the type calculator to infer types from Ruby in general, it
 # may not provide the wanted answer; it does not for instance take module inclusions and extensions into account. In general the type
 # system should be unsurprising for anyone being exposed to the notion of type. The type `Data` may require a bit more explanation; this
 # is an abstract type that includes all scalar types, as well as Array with an element type compatible with Data, and Hash with key
 # compatible with scalar and elements compatible with Data. Expressed differently; Data is what you typically express using JSON (with
 # the exception that the Puppet type system also includes Pattern (regular expression) as a scalar.
 #
 # Inference
 # ---------
 # The `infer(o)` method infers a Puppet type for scalar Ruby objects, and for Arrays and Hashes.
 # The inference result is instance specific for single typed collections
 # and allows answering questions about its embedded type. It does not however preserve multiple types in
 # a collection, and can thus not answer questions like `[1,a].infer() =~ Array[Integer, String]` since the inference
 # computes the common type Scalar when combining Integer and String.
 #
 # The `infer_generic(o)` method infers a generic Puppet type for scalar Ruby object, Arrays and Hashes.
 # This inference result does not contain instance specific information; e.g. Array[Integer] where the integer
 # range is the generic default. Just `infer` it also combines types into a common type.
 #
 # The `infer_set(o)` method works like `infer` but preserves all type information. It does not do any
 # reduction into common types or ranges. This method of inference is best suited for answering questions
 # about an object being an instance of a type. It correctly answers: `[1,a].infer_set() =~ Array[Integer, String]`
 #
 # The `generalize!(t)` method modifies an instance specific inference result to a generic. The method mutates
 # the given argument. Basically, this removes string instances from String, and range from Integer and Float.
 #
 # Assignability
 # -------------
 # The `assignable?(t1, t2)` method answers if t2 conforms to t1. The type t2 may be an instance, in which case
 # its type is inferred, or a type.
 #
 # Instance?
 # ---------
 # The `instance?(t, o)` method answers if the given object (instance) is an instance that is assignable to the given type.
 #
 # String
 # ------
 # Creates a string representation of a type.
 #
 # Creation of Type instances
 # --------------------------
 # Instance of the classes in the {Puppet::Pops::Types type model} are used to denote a specific type. It is most convenient
 # to use the {Puppet::Pops::Types::TypeFactory TypeFactory} when creating instances.
 #
 # @note
 #   In general, new instances of the wanted type should be created as they are assigned to models using containment, and a
 #   contained object can only be in one container at a time. Also, the type system may include more details in each type
 #   instance, such as if it may be nil, be empty, contain a certain count etc. Or put differently, the puppet types are not
 #   singletons.
 #
 # All types support `copy` which should be used when assigning a type where it is unknown if it is bound or not
 # to a parent type. A check can be made with `t.eContainer().nil?`
 #
 # Equality and Hash
 # -----------------
 # Type instances are equal in terms of Ruby eql? and `==` if they describe the same type, but they are not `equal?` if they are not
 # the same type instance. Two types that describe the same type have identical hash - this makes them usable as hash keys.
 #
 # Types and Subclasses
 # --------------------
 # In general, the type calculator should be used to answer questions if a type is a subtype of another (using {#assignable?}, or
 # {#instance?} if the question is if a given object is an instance of a given type (or is a subtype thereof).
 # Many of the types also have a Ruby subtype relationship; e.g. PHashType and PArrayType are both subtypes of PCollectionType, and
 # PIntegerType, PFloatType, PStringType,... are subtypes of PScalarType. Even if it is possible to answer certain questions about
 # type by looking at the Ruby class of the types this is considered an implementation detail, and such checks should in general
 # be performed by the type_calculator which implements the type system semantics.
 #
 # The PRubyType
 # -------------
 # The PRubyType corresponds to a Ruby Class, except for the puppet types that are specialized (i.e. PRubyType should not be
 # used for Integer, String, etc. since there are specialized types for those).
 # When the type calculator deals with PRubyTypes and checks for assignability, it determines the "common ancestor class" of two classes.
 # This check is made based on the superclasses of the two classes being compared. In order to perform this, the classes must be present
 # (i.e. they are resolved from the string form in the PRubyType to a loaded, instantiated Ruby Class). In general this is not a problem,
 # since the question to produce the common super type for two objects means that the classes must be present or there would have been
 # no instances present in the first place. If however the classes are not present, the type calculator will fall back and state that
 # the two types at least have Object in common.
 #
 # @see Puppet::Pops::Types::TypeFactory TypeFactory for how to create instances of types
 # @see Puppet::Pops::Types::TypeParser TypeParser how to construct a type instance from a String
 # @see Puppet::Pops::Types Types for details about the type model
 #
 # Using the Type Calculator
 # -----
 # The type calculator can be directly used via its class methods. If doing time critical work and doing many
 # calls to the type calculator, it is more performant to create an instance and invoke the corresponding
 # instance methods. Note that inference is an expensive operation, rather than infering the same thing
 # several times, it is in general better to infer once and then copy the result if mutation to a more generic form is
 # required.
 #
 # @api public
 #
 class Puppet::Pops::Types::TypeCalculator
 
   Types = Puppet::Pops::Types
   TheInfinity = 1.0 / 0.0 # because the Infinity symbol is not defined
 
   # @api public
   def self.assignable?(t1, t2)
     singleton.assignable?(t1,t2)
   end
 
   # Answers, does the given callable accept the arguments given in args (an array or a tuple)
   # @param callable [Puppet::Pops::Types::PCallableType] - the callable
   # @param args [Puppet::Pops::Types::PArrayType, Puppet::Pops::Types::PTupleType] args optionally including a lambda callable at the end
   # @return [Boolan] true if the callable accepts the arguments
   #
   # @api public
   def self.callable?(callable, args)
     singleton.callable?(callable, args)
   end
 
   # Produces a String representation of the given type.
   # @param t [Puppet::Pops::Types::PAbstractType] the type to produce a string form
   # @return [String] the type in string form
   #
   # @api public
   #
   def self.string(t)
     singleton.string(t)
   end
 
   # @api public
   def self.infer(o)
     singleton.infer(o)
   end
 
   # @api public
   def self.generalize!(o)
     singleton.generalize!(o)
   end
 
   # @api public
   def self.infer_set(o)
     singleton.infer_set(o)
   end
 
   # @api public
   def self.debug_string(t)
     singleton.debug_string(t)
   end
 
   # @api public
   def self.enumerable(t)
     singleton.enumerable(t)
   end
 
   # @api private
   def self.singleton()
     @tc_instance ||= new
   end
 
   # @api public
   #
   def initialize
     @@assignable_visitor ||= Puppet::Pops::Visitor.new(nil,"assignable",1,1)
     @@infer_visitor ||= Puppet::Pops::Visitor.new(nil,"infer",0,0)
     @@infer_set_visitor ||= Puppet::Pops::Visitor.new(nil,"infer_set",0,0)
     @@instance_of_visitor ||= Puppet::Pops::Visitor.new(nil,"instance_of",1,1)
     @@string_visitor ||= Puppet::Pops::Visitor.new(nil,"string",0,0)
     @@inspect_visitor ||= Puppet::Pops::Visitor.new(nil,"debug_string",0,0)
     @@enumerable_visitor ||= Puppet::Pops::Visitor.new(nil,"enumerable",0,0)
     @@extract_visitor ||= Puppet::Pops::Visitor.new(nil,"extract",0,0)
     @@generalize_visitor ||= Puppet::Pops::Visitor.new(nil,"generalize",0,0)
     @@callable_visitor ||= Puppet::Pops::Visitor.new(nil,"callable",1,1)
 
     da = Types::PArrayType.new()
     da.element_type = Types::PDataType.new()
     @data_array = da
 
     h = Types::PHashType.new()
     h.element_type = Types::PDataType.new()
     h.key_type = Types::PScalarType.new()
     @data_hash = h
 
     @data_t = Types::PDataType.new()
     @scalar_t = Types::PScalarType.new()
     @numeric_t = Types::PNumericType.new()
     @t = Types::PAnyType.new()
 
     # Data accepts a Tuple that has 0-infinity Data compatible entries (e.g. a Tuple equivalent to Array).
     data_tuple = Types::PTupleType.new()
     data_tuple.addTypes(Types::PDataType.new())
     data_tuple.size_type = Types::PIntegerType.new()
     data_tuple.size_type.from = 0
     data_tuple.size_type.to = nil # infinity
     @data_tuple_t = data_tuple
 
     # Variant type compatible with Data
     data_variant = Types::PVariantType.new()
     data_variant.addTypes(@data_hash.copy)
     data_variant.addTypes(@data_array.copy)
     data_variant.addTypes(Types::PScalarType.new)
     data_variant.addTypes(Types::PNilType.new)
     data_variant.addTypes(@data_tuple_t.copy)
     @data_variant_t = data_variant
 
     collection_default_size = Types::PIntegerType.new()
     collection_default_size.from = 0
     collection_default_size.to = nil # infinity
     @collection_default_size_t = collection_default_size
 
     non_empty_string = Types::PStringType.new
     non_empty_string.size_type = Types::PIntegerType.new()
     non_empty_string.size_type.from = 1
     non_empty_string.size_type.to = nil # infinity
     @non_empty_string_t = non_empty_string
 
     @nil_t = Types::PNilType.new
   end
 
   # Convenience method to get a data type for comparisons
   # @api private the returned value may not be contained in another element
   #
   def data
     @data_t
   end
 
   # Convenience method to get a variant compatible with the Data type.
   # @api private the returned value may not be contained in another element
   #
   def data_variant
     @data_variant_t
   end
 
   def self.data_variant
     singleton.data_variant
   end
 
   # Answers the question 'is it possible to inject an instance of the given class'
   # A class is injectable if it has a special *assisted inject* class method called `inject` taking
   # an injector and a scope as argument, or if it has a zero args `initialize` method.
   #
   # @param klazz [Class, PRubyType] the class/type to check if it is injectable
   # @return [Class, nil] the injectable Class, or nil if not injectable
   # @api public
   #
   def injectable_class(klazz)
     # Handle case when we get a PType instead of a class
     if klazz.is_a?(Types::PRubyType)
       klazz = Puppet::Pops::Types::ClassLoader.provide(klazz)
     end
 
     # data types can not be injected (check again, it is not safe to assume that given RubyType klazz arg was ok)
     return false unless type(klazz).is_a?(Types::PRubyType)
     if (klazz.respond_to?(:inject) && klazz.method(:inject).arity() == -4) || klazz.instance_method(:initialize).arity() == 0
       klazz
     else
       nil
     end
   end
 
   # Answers 'can an instance of type t2 be assigned to a variable of type t'.
   # Does not accept nil/undef unless the type accepts it.
   #
   # @api public
   #
   def assignable?(t, t2)
     if t.is_a?(Class)
       t = type(t)
     end
 
     if t2.is_a?(Class)
       t2 = type(t2)
     end
     # Unit can be assigned to anything
     return true if t2.class == Types::PUnitType
 
     @@assignable_visitor.visit_this_1(self, t, t2)
  end
 
   # Returns an enumerable if the t represents something that can be iterated
   def enumerable(t)
     @@enumerable_visitor.visit_this_0(self, t)
   end
 
   # Answers, does the given callable accept the arguments given in args (an array or a tuple)
   #
   def callable?(callable, args)
-    return false if !callable.is_a?(Types::PCallableType)
+    return false if !self.class.is_kind_of_callable?(callable)
     # Note that polymorphism is for the args type, the callable is always a callable
     @@callable_visitor.visit_this_1(self, args, callable)
   end
 
   # Answers if the two given types describe the same type
   def equals(left, right)
     return false unless left.is_a?(Types::PAbstractType) && right.is_a?(Types::PAbstractType)
     # Types compare per class only - an extra test must be made if the are mutually assignable
     # to find all types that represent the same type of instance
     #
     left  == right || (assignable?(right, left) && assignable?(left, right))
   end
 
   # Answers 'what is the Puppet Type corresponding to the given Ruby class'
   # @param c [Class] the class for which a puppet type is wanted
   # @api public
   #
   def type(c)
     raise ArgumentError, "Argument must be a Class" unless c.is_a? Class
 
     # Can't use a visitor here since we don't have an instance of the class
     case
     when c <= Integer
       type = Types::PIntegerType.new()
     when c == Float
       type = Types::PFloatType.new()
     when c == Numeric
       type = Types::PNumericType.new()
     when c == String
       type = Types::PStringType.new()
     when c == Regexp
       type = Types::PRegexpType.new()
     when c == NilClass
       type = Types::PNilType.new()
     when c == FalseClass, c == TrueClass
       type = Types::PBooleanType.new()
     when c == Class
       type = Types::PType.new()
     when c == Array
       # Assume array of data values
       type = Types::PArrayType.new()
       type.element_type = Types::PDataType.new()
     when c == Hash
       # Assume hash with scalar keys and data values
       type = Types::PHashType.new()
       type.key_type = Types::PScalarType.new()
       type.element_type = Types::PDataType.new()
     else
       type = Types::PRubyType.new()
       type.ruby_class = c.name
     end
     type
   end
 
   # Generalizes value specific types. The given type is mutated and returned.
   # @api public
   def generalize!(o)
     @@generalize_visitor.visit_this_0(self, o)
     o.eAllContents.each { |x| @@generalize_visitor.visit_this_0(self, x) }
     o
   end
 
   def generalize_Object(o)
     # do nothing, there is nothing to change for most types
   end
 
   def generalize_PStringType(o)
     o.values = []
     o.size_type = nil
     []
   end
 
   def generalize_PCollectionType(o)
     # erase the size constraint from Array and Hash (if one exists, it is transformed to -Infinity - + Infinity, which is
     # not desirable.
     o.size_type = nil
   end
 
   def generalize_PFloatType(o)
     o.to = nil
     o.from = nil
   end
 
   def generalize_PIntegerType(o)
     o.to = nil
     o.from = nil
   end
 
   # Answers 'what is the single common Puppet Type describing o', or if o is an Array or Hash, what is the
   # single common type of the elements (or keys and elements for a Hash).
   # @api public
   #
   def infer(o)
     @@infer_visitor.visit_this_0(self, o)
   end
 
   def infer_generic(o)
     result = generalize!(infer(o))
     result
   end
 
   # Answers 'what is the set of Puppet Types of o'
   # @api public
   #
   def infer_set(o)
     @@infer_set_visitor.visit_this_0(self, o)
   end
 
   def instance_of(t, o)
     @@instance_of_visitor.visit_this_1(self, t, o)
   end
 
   def instance_of_Object(t, o)
     # Undef is Undef and Any, but nothing else when checking instance?
     return false if (o.nil? || o == :undef) && t.class != Types::PAnyType
     assignable?(t, infer(o))
   end
 
   # Anything is an instance of Unit
   # @api private
   def instance_of_PUnitType(t, o)
     true
   end
 
   def instance_of_PArrayType(t, o)
     return false unless o.is_a?(Array)
     return false unless o.all? {|element| instance_of(t.element_type, element) }
     size_t = t.size_type || @collection_default_size_t
     size_t2 = size_as_type(o)
     assignable?(size_t, size_t2)
   end
 
   def instance_of_PTupleType(t, o)
     return false unless o.is_a?(Array)
     # compute the tuple's min/max size, and check if that size matches
     size_t = t.size_type || Puppet::Pops::Types::TypeFactory.range(*t.size_range)
 
     # compute the array's size as type
     size_t2 = size_as_type(o)
     return false unless assignable?(size_t, size_t2)
     o.each_with_index do |element, index|
        return false unless instance_of(t.types[index] || t.types[-1], element)
     end
     true
   end
 
   def instance_of_PStructType(t, o)
     return false unless o.is_a?(Hash)
     h = t.hashed_elements
     # all keys must be present and have a value (even if nil/undef)
     (o.keys - h.keys).empty? && h.all? { |k,v| instance_of(v, o[k]) }
   end
 
   def instance_of_PHashType(t, o)
     return false unless o.is_a?(Hash)
     key_t = t.key_type
     element_t = t.element_type
     return false unless o.keys.all? {|key| instance_of(key_t, key) } && o.values.all? {|value| instance_of(element_t, value) }
     size_t = t.size_type || @collection_default_size_t
     size_t2 = size_as_type(o)
     assignable?(size_t, size_t2)
   end
 
   def instance_of_PDataType(t, o)
     instance_of(@data_variant_t, o)
   end
 
   def instance_of_PNilType(t, o)
     return o.nil? || o == :undef
   end
 
   def instance_of_POptionalType(t, o)
     return true if (o.nil? || o == :undef)
     instance_of(t.optional_type, o)
   end
 
   def instance_of_PVariantType(t, o)
     # instance of variant if o is instance? of any of variant's types
     t.types.any? { |option_t| instance_of(option_t, o) }
   end
 
   # Answers 'is o an instance of type t'
   # @api public
   #
   def self.instance?(t, o)
     singleton.instance_of(t,o)
   end
 
   # Answers 'is o an instance of type t'
   # @api public
   #
   def instance?(t, o)
     instance_of(t,o)
   end
 
   # Answers if t is a puppet type
   # @api public
   #
   def is_ptype?(t)
     return t.is_a?(Types::PAbstractType)
   end
 
   # Answers if t represents the puppet type PNilType
   # @api public
   #
   def is_pnil?(t)
     return t.nil? || t.is_a?(Types::PNilType)
   end
 
   # Answers, 'What is the common type of t1 and t2?'
   #
   # TODO: The current implementation should be optimized for performance
   #
   # @api public
   #
   def common_type(t1, t2)
     raise ArgumentError, 'two types expected' unless (is_ptype?(t1) || is_pnil?(t1)) && (is_ptype?(t2) || is_pnil?(t2))
 
     # TODO: This is not right since Scalar U Undef is Any
     # if either is nil, the common type is the other
     if is_pnil?(t1)
       return t2
     elsif is_pnil?(t2)
       return t1
     end
 
     # If either side is Unit, it is the other type
     if t1.is_a?(Types::PUnitType)
       return t2
     elsif t2.is_a?(Types::PUnitType)
       return t1
     end
 
     # Simple case, one is assignable to the other
     if assignable?(t1, t2)
       return t1
     elsif assignable?(t2, t1)
       return t2
     end
 
     # when both are arrays, return an array with common element type
     if t1.is_a?(Types::PArrayType) && t2.is_a?(Types::PArrayType)
       type = Types::PArrayType.new()
       type.element_type = common_type(t1.element_type, t2.element_type)
       return type
     end
 
     # when both are hashes, return a hash with common key- and element type
     if t1.is_a?(Types::PHashType) && t2.is_a?(Types::PHashType)
       type = Types::PHashType.new()
       type.key_type = common_type(t1.key_type, t2.key_type)
       type.element_type = common_type(t1.element_type, t2.element_type)
       return type
     end
 
     # when both are host-classes, reduce to PHostClass[] (since one was not assignable to the other)
     if t1.is_a?(Types::PHostClassType) && t2.is_a?(Types::PHostClassType)
       return Types::PHostClassType.new()
     end
 
     # when both are resources, reduce to Resource[T] or Resource[] (since one was not assignable to the other)
     if t1.is_a?(Types::PResourceType) && t2.is_a?(Types::PResourceType)
       result = Types::PResourceType.new()
       # only Resource[] unless the type name is the same
       if t1.type_name == t2.type_name then result.type_name = t1.type_name end
       # the cross assignability test above has already determined that they do not have the same type and title
       return result
     end
 
     # Integers have range, expand the range to the common range
     if t1.is_a?(Types::PIntegerType) && t2.is_a?(Types::PIntegerType)
       t1range = from_to_ordered(t1.from, t1.to)
       t2range = from_to_ordered(t2.from, t2.to)
       t = Types::PIntegerType.new()
       from = [t1range[0], t2range[0]].min
       to = [t1range[1], t2range[1]].max
       t.from = from unless from == TheInfinity
       t.to = to unless to == TheInfinity
       return t
     end
 
     # Floats have range, expand the range to the common range
     if t1.is_a?(Types::PFloatType) && t2.is_a?(Types::PFloatType)
       t1range = from_to_ordered(t1.from, t1.to)
       t2range = from_to_ordered(t2.from, t2.to)
       t = Types::PFloatType.new()
       from = [t1range[0], t2range[0]].min
       to = [t1range[1], t2range[1]].max
       t.from = from unless from == TheInfinity
       t.to = to unless to == TheInfinity
       return t
     end
 
     if t1.is_a?(Types::PStringType) && t2.is_a?(Types::PStringType)
       t = Types::PStringType.new()
       t.values = t1.values | t2.values
       return t
     end
 
     if t1.is_a?(Types::PPatternType) && t2.is_a?(Types::PPatternType)
       t = Types::PPatternType.new()
       # must make copies since patterns are contained types, not data-types
       t.patterns = (t1.patterns | t2.patterns).map {|p| p.copy }
       return t
     end
 
     if t1.is_a?(Types::PEnumType) && t2.is_a?(Types::PEnumType)
       # The common type is one that complies with either set
       t = Types::PEnumType.new
       t.values = t1.values | t2.values
       return t
     end
 
     if t1.is_a?(Types::PVariantType) && t2.is_a?(Types::PVariantType)
       # The common type is one that complies with either set
       t = Types::PVariantType.new
       t.types = (t1.types | t2.types).map {|opt_t| opt_t.copy }
       return t
     end
 
     if t1.is_a?(Types::PRegexpType) && t2.is_a?(Types::PRegexpType)
       # if they were identical, the general rule would return a parameterized regexp
       # since they were not, the result is a generic regexp type
       return Types::PPatternType.new()
     end
 
     if t1.is_a?(Types::PCallableType) && t2.is_a?(Types::PCallableType)
       # They do not have the same signature, and one is not assignable to the other,
       # what remains is the most general form of Callable
       return Types::PCallableType.new()
     end
 
     # Common abstract types, from most specific to most general
     if common_numeric?(t1, t2)
       return Types::PNumericType.new()
     end
 
     if common_scalar?(t1, t2)
       return Types::PScalarType.new()
     end
 
     if common_data?(t1,t2)
       return Types::PDataType.new()
     end
 
     # Meta types Type[Integer] + Type[String] => Type[Data]
     if t1.is_a?(Types::PType) && t2.is_a?(Types::PType)
       type = Types::PType.new()
       type.type = common_type(t1.type, t2.type)
       return type
     end
 
     if t1.is_a?(Types::PRubyType) && t2.is_a?(Types::PRubyType)
       if t1.ruby_class == t2.ruby_class
         return t1
       end
       # finding the common super class requires that names are resolved to class
       c1 = Types::ClassLoader.provide_from_type(t1)
       c2 = Types::ClassLoader.provide_from_type(t2)
       if c1 && c2
         c2_superclasses = superclasses(c2)
         superclasses(c1).each do|c1_super|
           c2_superclasses.each do |c2_super|
             if c1_super == c2_super
               result = Types::PRubyType.new()
               result.ruby_class = c1_super.name
               return result
             end
           end
         end
       end
     end
     # If both are RubyObjects
 
     if common_pobject?(t1, t2)
       return Types::PAnyType.new()
     end
   end
 
   # Produces the superclasses of the given class, including the class
   def superclasses(c)
     result = [c]
     while s = c.superclass
       result << s
       c = s
     end
     result
   end
 
   # Produces a string representing the type
   # @api public
   #
   def string(t)
     @@string_visitor.visit_this_0(self, t)
   end
 
   # Produces a debug string representing the type (possibly with more information that the regular string format)
   # @api public
   #
   def debug_string(t)
     @@inspect_visitor.visit_this_0(self, t)
   end
 
 
   # Reduces an enumerable of types to a single common type.
   # @api public
   #
   def reduce_type(enumerable)
     enumerable.reduce(nil) {|memo, t| common_type(memo, t) }
   end
 
   # Reduce an enumerable of objects to a single common type
   # @api public
   #
   def infer_and_reduce_type(enumerable)
     reduce_type(enumerable.collect() {|o| infer(o) })
   end
 
   # The type of all classes is PType
   # @api private
   #
   def infer_Class(o)
     Types::PType.new()
   end
 
   # @api private
   def infer_Closure(o)
     o.type()
   end
 
   # @api private
   def infer_Function(o)
     o.class.dispatcher.to_type
   end
 
   # @api private
   def infer_Object(o)
     type = Types::PRubyType.new()
     type.ruby_class = o.class.name
     type
   end
 
   # The type of all types is PType
   # @api private
   #
   def infer_PAbstractType(o)
     type = Types::PType.new()
     type.type = o.copy
     type
   end
 
   # The type of all types is PType
   # This is the metatype short circuit.
   # @api private
   #
   def infer_PType(o)
     type = Types::PType.new()
     type.type = o.copy
     type
   end
 
   # @api private
   def infer_String(o)
     t = Types::PStringType.new()
     t.addValues(o)
     t.size_type = size_as_type(o)
     t
   end
 
   # @api private
   def infer_Float(o)
     t = Types::PFloatType.new()
     t.from = o
     t.to = o
     t
   end
 
   # @api private
   def infer_Integer(o)
     t = Types::PIntegerType.new()
     t.from = o
     t.to = o
     t
   end
 
   # @api private
   def infer_Regexp(o)
     t = Types::PRegexpType.new()
     t.pattern = o.source
     t
   end
 
   # @api private
   def infer_NilClass(o)
     Types::PNilType.new()
   end
 
   # Inference of :undef as PNilType, all other are Ruby[Symbol]
   # @api private
   def infer_Symbol(o)
     o == :undef ? infer_NilClass(o) : infer_Object(o)
   end
 
   # @api private
   def infer_TrueClass(o)
     Types::PBooleanType.new()
   end
 
   # @api private
   def infer_FalseClass(o)
     Types::PBooleanType.new()
   end
 
   # @api private
   # A Puppet::Parser::Resource, or Puppet::Resource
   #
   def infer_Resource(o)
     t = Types::PResourceType.new()
     t.type_name = o.type.to_s.downcase
     # Only Puppet::Resource can have a title that is a symbol :undef, a PResource cannot.
     # A mapping must be made to empty string. A nil value will result in an error later
     title = o.title
     t.title = (title == :undef ? '' : title)
     type = Types::PType.new()
     type.type = t
     type
   end
 
   # @api private
   def infer_Array(o)
     type = Types::PArrayType.new()
     type.element_type =
     if o.empty?
       Types::PNilType.new()
     else
       infer_and_reduce_type(o)
     end
     type.size_type = size_as_type(o)
     type
   end
 
   # @api private
   def infer_Hash(o)
     type = Types::PHashType.new()
     if o.empty?
       ktype = Types::PNilType.new()
       etype = Types::PNilType.new()
     else
       ktype = infer_and_reduce_type(o.keys())
       etype = infer_and_reduce_type(o.values())
     end
     type.key_type = ktype
     type.element_type = etype
     type.size_type = size_as_type(o)
     type
   end
 
   def size_as_type(collection)
     size = collection.size
     t = Types::PIntegerType.new()
     t.from = size
     t.to = size
     t
   end
 
   # Common case for everything that intrinsically only has a single type
   def infer_set_Object(o)
     infer(o)
   end
 
   def infer_set_Array(o)
     if o.empty?
       type = Types::PArrayType.new()
       type.element_type = Types::PNilType.new()
       type.size_type = size_as_type(o)
     else
       type = Types::PTupleType.new()
       type.types = o.map() {|x| infer_set(x) }
     end
     type
   end
 
   def infer_set_Hash(o)
     type = Types::PHashType.new()
     if o.empty?
       ktype = Types::PNilType.new()
       vtype = Types::PNilType.new()
     else
       ktype = Types::PVariantType.new()
       ktype.types = o.keys.map() {|k| infer_set(k) }
       etype = Types::PVariantType.new()
       etype.types = o.values.map() {|e| infer_set(e) }
     end
     type.key_type = unwrap_single_variant(ktype)
     type.element_type = unwrap_single_variant(etype)
     type.size_type = size_as_type(o)
     type
   end
 
   def unwrap_single_variant(possible_variant)
     if possible_variant.is_a?(Types::PVariantType) && possible_variant.types.size == 1
       possible_variant.types[0]
     else
       possible_variant
     end
   end
 
   # False in general type calculator
   # @api private
   def assignable_Object(t, t2)
     false
   end
 
   # @api private
   def assignable_PAnyType(t, t2)
     t2.is_a?(Types::PAnyType)
   end
 
   # @api private
   def assignable_PNilType(t, t2)
     # Only undef/nil is assignable to nil type
     t2.is_a?(Types::PNilType)
   end
 
   # Anything is assignable to a Unit type
   # @api private
   def assignable_PUnitType(t, t2)
     true
   end
 
   # @api private
   def assignable_PScalarType(t, t2)
     t2.is_a?(Types::PScalarType)
   end
 
   # @api private
   def assignable_PNumericType(t, t2)
     t2.is_a?(Types::PNumericType)
   end
 
   # @api private
   def assignable_PIntegerType(t, t2)
     return false unless t2.is_a?(Types::PIntegerType)
     trange =  from_to_ordered(t.from, t.to)
     t2range = from_to_ordered(t2.from, t2.to)
     # If t2 min and max are within the range of t
     trange[0] <= t2range[0] && trange[1] >= t2range[1]
   end
 
   # Transform int range to a size constraint
   # if range == nil the constraint is 1,1
   # if range.from == nil min size = 1
   # if range.to == nil max size == Infinity
   #
   def size_range(range)
     return [1,1] if range.nil?
     from = range.from
     to = range.to
     x = from.nil? ? 1 : from
     y = to.nil? ? TheInfinity : to
     if x < y
       [x, y]
     else
       [y, x]
     end
   end
 
   # @api private
   def from_to_ordered(from, to)
     x = (from.nil? || from == :default) ? -TheInfinity : from
     y = (to.nil? || to == :default) ? TheInfinity : to
     if x < y
       [x, y]
     else
       [y, x]
     end
   end
 
   # @api private
   def assignable_PVariantType(t, t2)
     # Data is a specific variant
     t2 = @data_variant_t if t2.is_a?(Types::PDataType)
     if t2.is_a?(Types::PVariantType)
       # A variant is assignable if all of its options are assignable to one of this type's options
       return true if t == t2
       t2.types.all? do |other|
         # if the other is a Variant, all if its options, but be assignable to one of this type's options
         other = other.is_a?(Types::PDataType) ? @data_variant_t : other
         if other.is_a?(Types::PVariantType)
           assignable?(t, other)
         else
           t.types.any? {|option_t| assignable?(option_t, other) }
         end
       end
     else
       # A variant is assignable if t2 is assignable to any of its types
       t.types.any? { |option_t| assignable?(option_t, t2) }
     end
   end
 
   # Catch all not callable combinations
   def callable_Object(o, callable_t)
     false
   end
 
   def callable_PTupleType(args_tuple, callable_t)
     if args_tuple.size_type
       raise ArgumentError, "Callable tuple may not have a size constraint when used as args"
     end
     # Assume no block was given - i.e. it is nil, and its type is PNilType
     block_t = @nil_t
-    if args_tuple.types.last.is_a?(Types::PCallableType)
+    if self.class.is_kind_of_callable?(args_tuple.types.last)
       # a split is needed to make it possible to use required, optional, and varargs semantics
       # of the tuple type.
       #
       args_tuple = args_tuple.copy
       # to drop the callable, it must be removed explicitly since this is an rgen array
       args_tuple.removeTypes(block_t = args_tuple.types.last())
     else
       # no block was given, if it is required, the below will fail
     end
     # unless argument types match parameter types
     return false unless assignable?(callable_t.param_types, args_tuple)
     # can the given block be *called* with a signature requirement specified by callable_t?
     assignable?(callable_t.block_type || @nil_t, block_t)
   end
 
+  # @api private
+  def self.is_kind_of_callable?(t, optional = true)
+    case t
+    when Types::PCallableType
+      true
+    when Types::POptionalType
+      optional && is_kind_of_callable?(t.optional_type, optional)
+    when Types::PVariantType
+      t.types.all? {|t2| is_kind_of_callable?(t2, optional) }
+    else
+      false
+    end
+  end
+
+
   def callable_PArrayType(args_array, callable_t)
     return false unless assignable?(callable_t.param_types, args_array)
     # does not support calling with a block, but have to check that callable is ok with missing block
     assignable?(callable_t.block_type || @nil_t, @nil_t)
   end
 
   def callable_PNilType(nil_t, callable_t)
     # if callable_t is Optional (or indeed PNilType), this means that 'missing callable' is accepted
     assignable?(callable_t, nil_t)
   end
 
   def callable_PCallableType(given_callable_t, required_callable_t)
     # If the required callable is euqal or more specific than the given, the given is callable
     assignable?(required_callable_t, given_callable_t)
   end
 
   def max(a,b)
     a >=b ? a : b
   end
 
   def min(a,b)
     a <= b ? a : b
   end
 
   def assignable_PTupleType(t, t2)
     return true if t == t2 || t.types.empty? && (t2.is_a?(Types::PArrayType))
     size_t = t.size_type || Puppet::Pops::Types::TypeFactory.range(*t.size_range)
 
     if t2.is_a?(Types::PTupleType)
       size_t2 = t2.size_type || Puppet::Pops::Types::TypeFactory.range(*t2.size_range)
 
       # not assignable if the number of types in t2 is outside number of types in t1
       if assignable?(size_t, size_t2)
         t2.types.size.times do |index|
           return false unless assignable?((t.types[index] || t.types[-1]), t2.types[index])
         end
         return true
       else
         return false
       end
     elsif t2.is_a?(Types::PArrayType)
       t2_entry = t2.element_type
 
       # Array of anything can not be assigned (unless tuple is tuple of anything) - this case
       # was handled at the top of this method.
       #
       return false if t2_entry.nil?
       size_t = t.size_type || Puppet::Pops::Types::TypeFactory.range(*t.size_range)
       size_t2 = t2.size_type || @collection_default_size_t
       return false unless assignable?(size_t, size_t2)
       min(t.types.size, size_t2.range()[1]).times do |index|
         return false unless assignable?((t.types[index] || t.types[-1]), t2_entry)
       end
       true
     else
       false
     end
   end
 
   # Produces the tuple entry at the given index given a tuple type, its from/to constraints on the last
   # type, and an index.
   # Produces nil if the index is out of bounds
   # from must be less than to, and from may not be less than 0
   #
   # @api private
   #
   def tuple_entry_at(tuple_t, from, to, index)
     regular = (tuple_t.types.size - 1)
     if index < regular
       tuple_t.types[index]
     elsif index < regular + to
       # in the varargs part
       tuple_t.types[-1]
     else
       nil
     end
   end
 
   # @api private
   #
   def assignable_PStructType(t, t2)
     return true if t == t2 || t.elements.empty? && (t2.is_a?(Types::PHashType))
     h = t.hashed_elements
     if t2.is_a?(Types::PStructType)
       h2 = t2.hashed_elements
       h.size == h2.size && h.all? {|k, v| assignable?(v, h2[k]) }
     elsif t2.is_a?(Types::PHashType)
       size_t2 = t2.size_type || @collection_default_size_t
       size_t = Types::PIntegerType.new
       size_t.from = size_t.to = h.size
       # compatible size
       # hash key type must be string of min 1 size
       # hash value t must be assignable to each key
       element_type = t2.element_type
       assignable?(size_t, size_t2) &&
         assignable?(@non_empty_string_t, t2.key_type) &&
         h.all? {|k,v| assignable?(v, element_type) }
     else
       false
     end
   end
 
   # @api private
   def assignable_POptionalType(t, t2)
     return true if t2.is_a?(Types::PNilType)
     if t2.is_a?(Types::POptionalType)
       assignable?(t.optional_type, t2.optional_type)
     else
       assignable?(t.optional_type, t2)
     end
   end
 
   # @api private
   def assignable_PEnumType(t, t2)
     return true if t == t2 || (t.values.empty? && (t2.is_a?(Types::PStringType) || t2.is_a?(Types::PEnumType)))
     if t2.is_a?(Types::PStringType)
       # if the set of strings are all found in the set of enums
       t2.values.all? { |s| t.values.any? { |e| e == s }}
     else
       false
     end
   end
 
   # @api private
   def assignable_PStringType(t, t2)
     if t.values.empty?
       # A general string is assignable by any other string or pattern restricted string
       # if the string has a size constraint it does not match since there is no reasonable way
       # to compute the min/max length a pattern will match. For enum, it is possible to test that
       # each enumerator value is within range
       size_t = t.size_type || @collection_default_size_t
       case t2
       when Types::PStringType
         # true if size compliant
         size_t2 = t2.size_type || @collection_default_size_t
         assignable?(size_t, size_t2)
 
       when Types::PPatternType
         # true if size constraint is at least 0 to +Infinity (which is the same as the default)
         assignable?(size_t, @collection_default_size_t)
 
       when Types::PEnumType
         if t2.values
           # true if all enum values are within range
           min, max = t2.values.map(&:size).minmax
           trange =  from_to_ordered(size_t.from, size_t.to)
           t2range = [min, max]
           # If t2 min and max are within the range of t
           trange[0] <= t2range[0] && trange[1] >= t2range[1]
         else
           # no string can match this enum anyway since it does not accept anything
           false
         end
       else
         # no other type matches string
         false
       end
     elsif t2.is_a?(Types::PStringType)
       # A specific string acts as a set of strings - must have exactly the same strings
       # In this case, size does not matter since the definition is very precise anyway
       Set.new(t.values) == Set.new(t2.values)
     else
       # All others are false, since no other type describes the same set of specific strings
       false
     end
   end
 
   # @api private
   def assignable_PPatternType(t, t2)
     return true if t == t2
     return false unless t2.is_a?(Types::PStringType) || t2.is_a?(Types::PEnumType)
 
     if t2.values.empty?
       # Strings / Enums (unknown which ones) cannot all match a pattern, but if there is no pattern it is ok
       # (There should really always be a pattern, but better safe than sorry).
       return t.patterns.empty? ? true : false
     end
     # all strings in String/Enum type must match one of the patterns in Pattern type
     regexps = t.patterns.map {|p| p.regexp }
     t2.values.all? { |v| regexps.any? {|re| re.match(v) } }
   end
 
   # @api private
   def assignable_PFloatType(t, t2)
     return false unless t2.is_a?(Types::PFloatType)
     trange =  from_to_ordered(t.from, t.to)
     t2range = from_to_ordered(t2.from, t2.to)
     # If t2 min and max are within the range of t
     trange[0] <= t2range[0] && trange[1] >= t2range[1]
   end
 
   # @api private
   def assignable_PBooleanType(t, t2)
     t2.is_a?(Types::PBooleanType)
   end
 
   # @api private
   def assignable_PRegexpType(t, t2)
     t2.is_a?(Types::PRegexpType) && (t.pattern.nil? || t.pattern == t2.pattern)
   end
 
   # @api private
   def assignable_PCallableType(t, t2)
     return false unless t2.is_a?(Types::PCallableType)
     # nil param_types means, any other Callable is assignable
     return true if t.param_types.nil?
 
     # NOTE: these tests are made in reverse as it is calling the callable that is constrained
     # (it's lower bound), not its upper bound
     return false unless assignable?(t2.param_types, t.param_types)
     # names are ignored, they are just information
     # Blocks must be compatible
     this_block_t = t.block_type || @nil_t
     that_block_t = t2.block_type || @nil_t
     assignable?(that_block_t, this_block_t)
 
-#    return false unless assignable?(t.param_types, t2.param_types)
-#    # names are ignored, they are just information
-#    # Blocks must be compatible
-#    this_block_t = t.block_type || @nil_t
-#    that_block_t = t2.block_type || @nil_t
-#    assignable?(this_block_t, that_block_t)
   end
 
   # @api private
   def assignable_PCollectionType(t, t2)
     size_t = t.size_type || @collection_default_size_t
     case t2
     when Types::PCollectionType
       size_t2 = t2.size_type || @collection_default_size_t
       assignable?(size_t, size_t2)
     when Types::PTupleType
       # compute the tuple's min/max size, and check if that size matches
       from, to = size_range(t2.size_type)
       t2s = Types::PIntegerType.new()
       t2s.from = t2.types.size - 1 + from
       t2s.to = t2.types.size - 1 + to
       assignable?(size_t, t2s)
     when Types::PStructType
       from = to = t2.elements.size
       t2s = Types::PIntegerType.new()
       t2s.from = from
       t2s.to = to
       assignable?(size_t, t2s)
     else
       false
     end
   end
 
   # @api private
   def assignable_PType(t, t2)
     return false unless t2.is_a?(Types::PType)
     return true if t.type.nil? # wide enough to handle all types
     return false if t2.type.nil? # wider than t
     assignable?(t.type, t2.type)
   end
 
   # Array is assignable if t2 is an Array and t2's element type is assignable, or if t2 is a Tuple
   # where 
   # @api private
   def assignable_PArrayType(t, t2)
     if t2.is_a?(Types::PArrayType)
       return false unless assignable?(t.element_type, t2.element_type)
       assignable_PCollectionType(t, t2)
 
     elsif t2.is_a?(Types::PTupleType)
       return false unless t2.types.all? {|t2_element| assignable?(t.element_type, t2_element) }
       t2_regular = t2.types[0..-2]
       t2_ranged = t2.types[-1]
       t2_from, t2_to = size_range(t2.size_type)
       t2_required = t2_regular.size + t2_from
 
       t_entry = t.element_type
 
       # Tuple of anything can not be assigned (unless array is tuple of anything) - this case
       # was handled at the top of this method.
       #
       return false if t_entry.nil?
 
       # array type may be size constrained
       size_t = t.size_type || @collection_default_size_t
       min, max = size_t.range
       # Tuple with fewer min entries can not be assigned
       return false if t2_required < min
       # Tuple with more optionally available entries can not be assigned
       return false if t2_regular.size + t2_to > max
       # each tuple type must be assignable to the element type
       t2_required.times do |index|
         t2_entry = tuple_entry_at(t2, t2_from, t2_to, index)
         return false unless assignable?(t_entry, t2_entry)
       end
       # ... and so must the last, possibly optional (ranged) type
       return assignable?(t_entry, t2_ranged)
     else
       false
     end
   end
 
   # Hash is assignable if t2 is a Hash and t2's key and element types are assignable
   # @api private
   def assignable_PHashType(t, t2)
     case t2
     when Types::PHashType
       return false unless assignable?(t.key_type, t2.key_type) && assignable?(t.element_type, t2.element_type)
       assignable_PCollectionType(t, t2)
     when Types::PStructType
       # hash must accept String as key type
       # hash must accept all value types
       # hash must accept the size of the struct
       size_t = t.size_type || @collection_default_size_t
       min, max = size_t.range
       struct_size = t2.elements.size
       element_type = t.element_type
       ( struct_size >= min && struct_size <= max &&
         assignable?(t.key_type, @non_empty_string_t)  &&
         t2.hashed_elements.all? {|k,v| assignable?(element_type, v) })
     else
       false
     end
   end
 
   # @api private
   def assignable_PCatalogEntryType(t1, t2)
     t2.is_a?(Types::PCatalogEntryType)
   end
 
   # @api private
   def assignable_PHostClassType(t1, t2)
     return false unless t2.is_a?(Types::PHostClassType)
     # Class = Class[name}, Class[name] != Class
     return true if t1.class_name.nil?
     # Class[name] = Class[name]
     return t1.class_name == t2.class_name
   end
 
   # @api private
   def assignable_PResourceType(t1, t2)
     return false unless t2.is_a?(Types::PResourceType)
     return true if t1.type_name.nil?
     return false if t1.type_name != t2.type_name
     return true if t1.title.nil?
     return t1.title == t2.title
   end
 
   # Data is assignable by other Data and by Array[Data] and Hash[Scalar, Data]
   # @api private
   def assignable_PDataType(t, t2)
     t2.is_a?(Types::PDataType) || assignable?(@data_variant_t, t2)
   end
 
   # Assignable if t2's ruby class is same or subclass of t1's ruby class
   # @api private
   def assignable_PRubyType(t1, t2)
     return false unless t2.is_a?(Types::PRubyType)
     return true if t1.ruby_class.nil?   # t1 is wider
     return false if t2.ruby_class.nil?  # t1 not nil, so t2 can not be wider
     c1 = class_from_string(t1.ruby_class)
     c2 = class_from_string(t2.ruby_class)
     return false unless c1.is_a?(Class) && c2.is_a?(Class)
     !!(c2 <= c1)
   end
 
   # @api private
   def debug_string_Object(t)
     string(t)
   end
 
   # @api private
   def string_PType(t)
     if t.type.nil?
       "Type"
     else
       "Type[#{string(t.type)}]"
     end
   end
 
   # @api private
   def string_NilClass(t)     ; '?'       ; end
 
   # @api private
   def string_String(t)       ; t         ; end
 
   # @api private
   def string_PAnyType(t)  ; "Any"  ; end
 
   # @api private
   def string_PNilType(t)     ; 'Undef'   ; end
 
   # @api private
   def string_PBooleanType(t) ; "Boolean" ; end
 
   # @api private
   def string_PScalarType(t) ; "Scalar" ; end
 
   # @api private
   def string_PDataType(t)    ; "Data"    ; end
 
   # @api private
   def string_PNumericType(t) ; "Numeric" ; end
 
   # @api private
   def string_PIntegerType(t)
     range = range_array_part(t)
     unless range.empty?
       "Integer[#{range.join(', ')}]"
     else
       "Integer"
     end
   end
 
   # Produces a string from an Integer range type that is used inside other type strings
   # @api private
   def range_array_part(t)
     return [] if t.nil? || (t.from.nil? && t.to.nil?)
     [t.from.nil? ? 'default' : t.from , t.to.nil? ? 'default' : t.to ]
   end
 
   # @api private
   def string_PFloatType(t)
     range = range_array_part(t)
     unless range.empty?
       "Float[#{range.join(', ')}]"
     else
       "Float"
     end
   end
 
   # @api private
   def string_PRegexpType(t)
     t.pattern.nil? ? "Regexp" : "Regexp[#{t.regexp.inspect}]"
   end
 
   # @api private
   def string_PStringType(t)
     # skip values in regular output - see debug_string
     range = range_array_part(t.size_type)
     unless range.empty?
       "String[#{range.join(', ')}]"
     else
       "String"
     end
   end
 
   # @api private
   def debug_string_PStringType(t)
     range = range_array_part(t.size_type)
     range_part = range.empty? ? '' : '[' << range.join(' ,') << '], '
     "String[" << range_part << (t.values.map {|s| "'#{s}'" }).join(', ') << ']'
   end
 
   # @api private
   def string_PEnumType(t)
     return "Enum" if t.values.empty?
     "Enum[" << t.values.map {|s| "'#{s}'" }.join(', ') << ']'
   end
 
   # @api private
   def string_PVariantType(t)
     return "Variant" if t.types.empty?
     "Variant[" << t.types.map {|t2| string(t2) }.join(', ') << ']'
   end
 
   # @api private
   def string_PTupleType(t)
     range = range_array_part(t.size_type)
     return "Tuple" if t.types.empty?
     s = "Tuple[" << t.types.map {|t2| string(t2) }.join(', ')
     unless range.empty?
       s << ", " << range.join(', ')
     end
     s << "]"
     s
   end
 
   # @api private
   def string_PCallableType(t)
     # generic
     return "Callable" if t.param_types.nil?
 
     if t.param_types.types.empty?
       range = [0, 0]
     else
       range = range_array_part(t.param_types.size_type)
     end
     # translate to string, and skip Unit types
     types = t.param_types.types.map {|t2| string(t2) unless t2.class == Types::PUnitType }.compact
 
     params_part= types.join(', ')
 
     s = "Callable[" << types.join(', ')
     unless range.empty?
       (s << ', ') unless types.empty?
       s << range.join(', ')
     end
     # Add block T last (after min, max) if present)
     #
     unless t.block_type.nil?
       (s << ', ') unless types.empty? && range.empty?
       s << string(t.block_type)
     end
     s << "]"
     s
   end
 
   # @api private
   def string_PStructType(t)
     return "Struct" if t.elements.empty?
     "Struct[{" << t.elements.map {|element| string(element) }.join(', ') << "}]"
   end
 
   def string_PStructElement(t)
     "'#{t.name}'=>#{string(t.type)}"
   end
 
   # @api private
   def string_PPatternType(t)
     return "Pattern" if t.patterns.empty?
     "Pattern[" << t.patterns.map {|s| "#{s.regexp.inspect}" }.join(', ') << ']'
   end
 
   # @api private
   def string_PCollectionType(t)
     range = range_array_part(t.size_type)
     unless range.empty?
       "Collection[#{range.join(', ')}]"
     else
       "Collection"
     end
   end
 
   # @api private
   def string_PUnitType(t)
     "Unit"
   end
 
   # @api private
   def string_PRubyType(t)   ; "Ruby[#{string(t.ruby_class)}]"  ; end
 
   # @api private
   def string_PArrayType(t)
     parts = [string(t.element_type)] + range_array_part(t.size_type)
     "Array[#{parts.join(', ')}]"
   end
 
   # @api private
   def string_PHashType(t)
     parts = [string(t.key_type), string(t.element_type)] + range_array_part(t.size_type)
     "Hash[#{parts.join(', ')}]"
   end
 
   # @api private
   def string_PCatalogEntryType(t)
     "CatalogEntry"
   end
 
   # @api private
   def string_PHostClassType(t)
     if t.class_name
       "Class[#{t.class_name}]"
     else
       "Class"
     end
   end
 
   # @api private
   def string_PResourceType(t)
     if t.type_name
       if t.title
         "#{capitalize_segments(t.type_name)}['#{t.title}']"
       else
         capitalize_segments(t.type_name)
       end
     else
       "Resource"
     end
   end
 
   def string_POptionalType(t)
     if t.optional_type.nil?
       "Optional"
     else
       "Optional[#{string(t.optional_type)}]"
     end
   end
 
   # Catches all non enumerable types
   # @api private
   def enumerable_Object(o)
     nil
   end
 
   # @api private
   def enumerable_PIntegerType(t)
     # Not enumerable if representing an infinite range
     return nil if t.size == TheInfinity
     t
   end
 
   def self.copy_as_tuple(t)
     case t
     when Types::PTupleType
       t.copy
     when Types::PArrayType
       # transform array to tuple
       result = Types::PTupleType.new
       result.addTypes(t.element_type.copy)
       result.size_type = t.size_type.nil? ? nil : t.size_type.copy
       result
     else
       raise ArgumentError, "Internal Error: Only Array and Tuple can be given to copy_as_tuple"
     end
   end
 
   private
 
   NAME_SEGMENT_SEPARATOR = '::'.freeze
 
   def capitalize_segments(s)
     s.split(NAME_SEGMENT_SEPARATOR).map(&:capitalize).join(NAME_SEGMENT_SEPARATOR)
   end
 
   def class_from_string(str)
     begin
       str.split(NAME_SEGMENT_SEPARATOR).inject(Object) do |memo, name_segment|
         memo.const_get(name_segment)
       end
     rescue NameError
       return nil
     end
   end
 
   def common_data?(t1, t2)
     assignable?(@data_t, t1) && assignable?(@data_t, t2)
   end
 
   def common_scalar?(t1, t2)
     assignable?(@scalar_t, t1) && assignable?(@scalar_t, t2)
   end
 
   def common_numeric?(t1, t2)
     assignable?(@numeric_t, t1) && assignable?(@numeric_t, t2)
   end
 
   def common_pobject?(t1, t2)
     assignable?(@t, t1) && assignable?(@t, t2)
   end
 end
diff --git a/lib/puppet/pops/types/type_factory.rb b/lib/puppet/pops/types/type_factory.rb
index c8fb8af67..d411fa5b2 100644
--- a/lib/puppet/pops/types/type_factory.rb
+++ b/lib/puppet/pops/types/type_factory.rb
@@ -1,405 +1,402 @@
 # Helper module that makes creation of type objects simpler.
 # @api public
 #
 module Puppet::Pops::Types::TypeFactory
   @type_calculator = Puppet::Pops::Types::TypeCalculator.new()
 
   Types = Puppet::Pops::Types
 
   # Produces the Integer type
   # @api public
   #
   def self.integer()
     Types::PIntegerType.new()
   end
 
   # Produces an Integer range type
   # @api public
   #
   def self.range(from, to)
     t = Types::PIntegerType.new()
     t.from = from unless (from == :default || from == 'default')
     t.to = to unless (to == :default || to == 'default')
     t
   end
 
   # Produces a Float range type
   # @api public
   #
   def self.float_range(from, to)
     t = Types::PFloatType.new()
     t.from = Float(from) unless from == :default || from.nil?
     t.to = Float(to) unless to == :default || to.nil?
     t
   end
 
   # Produces the Float type
   # @api public
   #
   def self.float()
     Types::PFloatType.new()
   end
 
   # Produces the Numeric type
   # @api public
   #
   def self.numeric()
     Types::PNumericType.new()
   end
 
   # Produces a string representation of the type
   # @api public
   #
   def self.label(t)
     @type_calculator.string(t)
   end
 
   # Produces the String type, optionally with specific string values
   # @api public
   #
   def self.string(*values)
     t = Types::PStringType.new()
     values.each {|v| t.addValues(v) }
     t
   end
 
   # Produces the Optional type, i.e. a short hand for Variant[T, Undef]
   def self.optional(optional_type = nil)
     t = Types::POptionalType.new
     t.optional_type = type_of(optional_type)
     t
   end
 
   # Produces the Enum type, optionally with specific string values
   # @api public
   #
   def self.enum(*values)
     t = Types::PEnumType.new()
     values.each {|v| t.addValues(v) }
     t
   end
 
   # Produces the Variant type, optionally with the "one of" types
   # @api public
   #
   def self.variant(*types)
     t = Types::PVariantType.new()
     types.each {|v| t.addTypes(type_of(v)) }
     t
   end
 
   # Produces the Struct type, either a non parameterized instance representing all structs (i.e. all hashes)
   # or a hash with a given set of keys of String type (names), bound to a value of a given type. Type may be
   # a Ruby Class, a Puppet Type, or an instance from which the type is inferred.
   #
   def self.struct(name_type_hash = {})
     t = Types::PStructType.new
     name_type_hash.map do |name, type|
       elem = Types::PStructElement.new
       if name.is_a?(String) && name.empty?
         raise ArgumentError, "An empty String can not be used where a String[1, default] is expected"
       end
       elem.name = name
       elem.type = type_of(type)
       elem
     end.each {|elem| t.addElements(elem) }
     t
   end
 
   def self.tuple(*types)
     t = Types::PTupleType.new
     types.each {|elem| t.addTypes(type_of(elem)) }
     t
   end
 
   # Produces the Boolean type
   # @api public
   #
   def self.boolean()
     Types::PBooleanType.new()
   end
 
   # Produces the Any type
   # @api public
   #
   def self.any()
     Types::PAnyType.new()
   end
 
   # Produces the Regexp type
   # @param pattern [Regexp, String, nil] (nil) The regular expression object or a regexp source string, or nil for bare type
   # @api public
   #
   def self.regexp(pattern = nil)
     t = Types::PRegexpType.new()
     if pattern
       t.pattern = pattern.is_a?(Regexp) ? pattern.inspect[1..-2] : pattern
     end
     t.regexp() unless pattern.nil? # compile pattern to catch errors
     t
   end
 
   def self.pattern(*regular_expressions)
     t = Types::PPatternType.new()
     regular_expressions.each do |re|
       case re
       when String
         re_T = Types::PRegexpType.new()
         re_T.pattern = re
         re_T.regexp()  # compile it to catch errors
         t.addPatterns(re_T)
 
       when Regexp
         re_T = Types::PRegexpType.new()
         # Regep.to_s includes options user did not enter and does not escape source
         # to work either as a string or as a // regexp. The inspect method does a better
         # job, but includes the //
         re_T.pattern = re.inspect[1..-2]
         t.addPatterns(re_T)
 
       when Types::PRegexpType
         t.addPatterns(re.copy)
 
       when Types::PPatternType
         re.patterns.each do |p|
           t.addPatterns(p.copy)
         end
 
      else
        raise ArgumentError, "Only String, Regexp, Pattern-Type, and Regexp-Type are allowed: got '#{re.class}"
       end
     end
     t
   end
 
   # Produces the Literal type
   # @api public
   #
   def self.scalar()
     Types::PScalarType.new()
   end
 
   # Produces a CallableType matching all callables
   # @api public
   #
   def self.all_callables()
     return Puppet::Pops::Types::PCallableType.new
   end
 
   # Produces a Callable type with one signature without support for a block
   # Use #with_block, or #with_optional_block to add a block to the callable
   # If no parameters are given, the Callable will describe a signature
   # that does not accept parameters. To create a Callable that matches all callables
   # use {#all_callables}.
   #
   # The params is a list of types, where the three last entries may be
   # optionally followed by min, max count, and a Callable which is taken as the block_type.
   # If neither min or max are specified the parameters must match exactly.
   # A min < params.size means that the difference are optional.
   # If max > params.size means that the last type repeats.
   # if max is :default, the max value is unbound (infinity).
   #
   # Params are given as a sequence of arguments to {#type_of}.
   #
   def self.callable(*params)
-    case params.last
-    when Types::PCallableType
+    if Puppet::Pops::Types::TypeCalculator.is_kind_of_callable?(params.last)
       last_callable = true
-    when Types::POptionalType
-      last_callable = true if params.last.optional_type.is_a?(Types::PCallableType)
     end
     block_t = last_callable ? params.pop : nil
 
     # compute a size_type for the signature based on the two last parameters
     if is_range_parameter?(params[-2]) && is_range_parameter?(params[-1])
       size_type = range(params[-2], params[-1])
       params = params[0, params.size - 2]
     elsif is_range_parameter?(params[-1])
       size_type = range(params[-1], :default)
       params = params[0, params.size - 1]
     end
 
     types = params.map {|p| type_of(p) }
 
     # If the specification requires types, and none were given, a Unit type is used
     if types.empty? && !size_type.nil? && size_type.size > 0
       types << Types::PUnitType.new
     end
     # create a signature
     callable_t = Types::PCallableType.new()
     tuple_t = tuple(*types)
     tuple_t.size_type = size_type unless size_type.nil?
     callable_t.param_types = tuple_t
 
     callable_t.block_type = block_t
     callable_t
   end
 
   def self.with_block(callable, *block_params)
     callable.block_type = callable(*block_params)
     callable
   end
 
   def self.with_optional_block(callable, *block_params)
     callable.block_type = optional(callable(*block_params))
     callable
   end
 
   # Produces the abstract type Collection
   # @api public
   #
   def self.collection()
     Types::PCollectionType.new()
   end
 
   # Produces the Data type
   # @api public
   #
   def self.data()
     Types::PDataType.new()
   end
 
   # Creates an instance of the Undef type
   # @api public
   def self.undef()
     Types::PNilType.new()
   end
 
   # Produces an instance of the abstract type PCatalogEntryType
   def self.catalog_entry()
     Types::PCatalogEntryType.new()
   end
 
   # Produces a PResourceType with a String type_name
   # A PResourceType with a nil or empty name is compatible with any other PResourceType.
   # A PResourceType with a given name is only compatible with a PResourceType with the same name.
   # (There is no resource-type subtyping in Puppet (yet)).
   #
   def self.resource(type_name = nil, title = nil)
     type = Types::PResourceType.new()
     type_name = type_name.type_name if type_name.is_a?(Types::PResourceType)
     type.type_name = type_name.downcase unless type_name.nil?
     type.title = title
     type
   end
 
   # Produces PHostClassType with a string class_name.
   # A PHostClassType with nil or empty name is compatible with any other PHostClassType.
   # A PHostClassType with a given name is only compatible with a PHostClassType with the same name.
   #
   def self.host_class(class_name = nil)
     type = Types::PHostClassType.new()
     unless class_name.nil?
       type.class_name = class_name.sub(/^::/, '')
     end
     type
   end
 
   # Produces a type for Array[o] where o is either a type, or an instance for which a type is inferred.
   # @api public
   #
   def self.array_of(o)
     type = Types::PArrayType.new()
     type.element_type = type_of(o)
     type
   end
 
   # Produces a type for Hash[Scalar, o] where o is either a type, or an instance for which a type is inferred.
   # @api public
   #
   def self.hash_of(value, key = scalar())
     type = Types::PHashType.new()
     type.key_type = type_of(key)
     type.element_type = type_of(value)
     type
   end
 
   # Produces a type for Array[Data]
   # @api public
   #
   def self.array_of_data()
     type = Types::PArrayType.new()
     type.element_type = data()
     type
   end
 
   # Produces a type for Hash[Scalar, Data]
   # @api public
   #
   def self.hash_of_data()
     type = Types::PHashType.new()
     type.key_type = scalar()
     type.element_type = data()
     type
   end
 
   # Produces a type for Type[T]
   # @api public
   #
   def self.type_type(inst_type = nil)
     type = Types::PType.new()
     type.type = inst_type
     type
   end
 
   # Produce a type corresponding to the class of given unless given is a String, Class or a PAbstractType.
   # When a String is given this is taken as a classname.
   #
   def self.type_of(o)
     if o.is_a?(Class)
       @type_calculator.type(o)
     elsif o.is_a?(Types::PAbstractType)
       o
     elsif o.is_a?(String)
       type = Types::PRubyType.new()
       type.ruby_class = o
       type
     else
       @type_calculator.infer_generic(o)
     end
   end
 
   # Produces a type for a class or infers a type for something that is not a class
   # @note
   #   To get the type for the class' class use `TypeCalculator.infer(c)`
   #
   # @overload ruby(o)
   #   @param o [Class] produces the type corresponding to the class (e.g. Integer becomes PIntegerType)
   # @overload ruby(o)
   #   @param o [Object] produces the type corresponding to the instance class (e.g. 3 becomes PIntegerType)
   #
   # @api public
   #
   def self.ruby(o)
     if o.is_a?(Class)
       @type_calculator.type(o)
     else
       type = Types::PRubyType.new()
       type.ruby_class = o.class.name
       type
     end
   end
 
   # Generic creator of a RubyType - allows creating the Ruby type with nil name, or String name.
   # Also see ruby(o) which performs inference, or mapps a Ruby Class to its name.
   #
   def self.ruby_type(class_name = nil)
     type = Types::PRubyType.new()
     type.ruby_class = class_name
     type
   end
 
   # Sets the accepted size range of a collection if something other than the default 0 to Infinity
   # is wanted. The semantics for from/to are the same as for #range
   #
   def self.constrain_size(collection_t, from, to)
     collection_t.size_type = range(from, to)
     collection_t
   end
 
   # Returns true if the given type t is of valid range parameter type (integer or literal default).
   def self.is_range_parameter?(t)
     t.is_a?(Integer) || t == 'default' || t == :default
   end
 
 end
diff --git a/lib/puppet/pops/types/types.rb b/lib/puppet/pops/types/types.rb
index a9924a43c..a6a47dcbb 100644
--- a/lib/puppet/pops/types/types.rb
+++ b/lib/puppet/pops/types/types.rb
@@ -1,510 +1,511 @@
 require 'rgen/metamodel_builder'
 
 # The Types model is a model of Puppet Language types.
 #
 # 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::Types
   # Used as end in a range
   INFINITY = 1.0 / 0.0
   NEGATIVE_INFINITY = -INFINITY
 
   class PAbstractType < Puppet::Pops::Model::PopsObject
     abstract
     module ClassModule
       # Produce a deep copy of the type
       def copy
         Marshal.load(Marshal.dump(self))
       end
 
       def hash
         self.class.hash
       end
 
       def ==(o)
         self.class == o.class
       end
 
       alias eql? ==
 
       def to_s
         Puppet::Pops::Types::TypeCalculator.string(self)
       end
     end
   end
 
   # Base type for all types except {Puppet::Pops::Types::PType PType}, the type of types.
   # @api public
   class PAnyType < PAbstractType
 
     module ClassModule
     end
 
   end
 
   # The type of types.
   # @api public
   class PType < PAnyType
     contains_one_uni 'type', PAbstractType
     module ClassModule
       def hash
         [self.class, type].hash
       end
 
       def ==(o)
         self.class == o.class && type == o.type
       end
     end
   end
 
   # @api public
   class PNilType < PAnyType
   end
 
   # A type private to the type system that describes "ignored type" - i.e. "I am what you are"
   # @api private
   class  PUnitType < PAnyType
   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()
       end
     end
   end
 
   # A flexible type describing an any? of other types
   # @api public
   class PVariantType < PAnyType
     contains_many_uni 'types', PAbstractType, :lowerBound => 1
 
     module ClassModule
 
       def hash
         [self.class, Set.new(self.types)].hash
       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
     end
   end
 
   # Type that is PDataType compatible, but is not a PCollectionType.
   # @api public
   class PScalarType < PAnyType
   end
 
   # A string type describing the set of strings having one of the given values
   #
   class PEnumType < PScalarType
     has_many_attr 'values', String, :lowerBound => 1
 
     module ClassModule
       def hash
         [self.class, Set.new(self.values)].hash
       end
 
       def ==(o)
         self.class == o.class && Set.new(values) == Set.new(o.values)
       end
     end
   end
 
   # @api public
   class PNumericType < PScalarType
   end
 
   # @api public
   class PIntegerType < PNumericType
     has_attr 'from', Integer, :lowerBound => 0
     has_attr 'to', Integer, :lowerBound => 0
 
     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 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 || NEGATIVE_INFINITY
         t = to || INFINITY
         if f < t
           [f, t]
         else
           [t,f]
         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 }
         else
           from.upto(to) {|x| yield x }
         end
       end
 
       def hash
         [self.class, from, to].hash
       end
 
       def ==(o)
         self.class == o.class && from == o.from && to == o.to
       end
     end
   end
 
   # @api public
   class PFloatType < PNumericType
     has_attr 'from', Float, :lowerBound => 0
     has_attr 'to', Float, :lowerBound => 0
 
     module ClassModule
       def hash
         [self.class, from, to].hash
       end
 
       def ==(o)
         self.class == o.class && from == o.from && to == o.to
       end
     end
   end
 
   # @api public
   class PStringType < PScalarType
     has_many_attr 'values', String, :lowerBound => 0, :upperBound => -1, :unique => true
     contains_one_uni 'size_type', PIntegerType
 
     module ClassModule
 
       def hash
         [self.class, self.size_type, Set.new(self.values)].hash
       end
 
       def ==(o)
         self.class == o.class && self.size_type == o.size_type && Set.new(values) == Set.new(o.values)
       end
     end
   end
 
   # @api public
   class PRegexpType < PScalarType
     has_attr 'pattern', String, :lowerBound => 1
     has_attr 'regexp', Object, :derived => true
 
     module ClassModule
       def regexp_derived
         @_regexp = Regexp.new(pattern) unless @_regexp && @_regexp.source == pattern
         @_regexp
       end
 
       def hash
         [self.class, pattern].hash
       end
 
       def ==(o)
         self.class == o.class && pattern == o.pattern
       end
     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
     contains_many_uni 'patterns', PRegexpType
 
     module ClassModule
 
       def hash
         [self.class, Set.new(patterns)].hash
       end
 
       def ==(o)
         self.class == o.class && Set.new(patterns) == Set.new(o.patterns)
       end
     end
   end
 
   # @api public
   class PBooleanType < PScalarType
   end
 
   # @api public
   class PCollectionType < PAnyType
     contains_one_uni 'element_type', PAbstractType
     contains_one_uni 'size_type', PIntegerType
 
     module ClassModule
       # Returns an array with from (min) size to (max) size
       def size_range
         return [0, INFINITY] if size_type.nil?
         f = size_type.from || 0
         t = size_type.to || INFINITY
         if f < t
           [f, t]
         else
           [t,f]
         end
       end
 
       def hash
         [self.class, element_type, size_type].hash
       end
 
       def ==(o)
         self.class == o.class && element_type == o.element_type && size_type == o.size_type
       end
     end
   end
 
   class PStructElement < Puppet::Pops::Model::PopsObject
     has_attr 'name', String, :lowerBound => 1
     contains_one_uni 'type', PAbstractType
 
     module ClassModule
       def hash
         [self.class, type, name].hash
       end
 
       def ==(o)
         self.class == o.class && type == o.type && name == o.name
       end
     end
   end
 
   # @api public
   class PStructType < PAnyType
     contains_many_uni 'elements', PStructElement, :lowerBound => 1
     has_attr 'hashed_elements', Object, :derived => true
 
     module ClassModule
       def hashed_elements_derived
         @_hashed ||= elements.reduce({}) {|memo, e| memo[e.name] = e.type; memo }
         @_hashed
       end
 
       def clear_hashed_elements
         @_hashed = nil
       end
 
       def hash
         [self.class, Set.new(elements)].hash
       end
 
       def ==(o)
         self.class == o.class && hashed_elements == o.hashed_elements
       end
     end
   end
 
   # @api public
   class PTupleType < PAnyType
     contains_many_uni 'types', PAbstractType, :lowerBound => 1
     # If set, describes min and max required of the given types - if max > size of
     # types, the last type entry repeats
     #
     contains_one_uni 'size_type', PIntegerType, :lowerBound => 0
 
     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]
         end
         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
         [self.class, size_type, Set.new(types)].hash
       end
 
       def ==(o)
         self.class == o.class && types == o.types && size_type == o.size_type
       end
     end
   end
 
   class PCallableType < PAnyType
     # Types of parameters as a Tuple with required/optional count, or an Integer with min (required), max count
     contains_one_uni 'param_types', PAnyType, :lowerBound => 1
 
-    # Although being an abstract type reference, only Callable, and Optional[Callable] are supported
+    # 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.
     #
     contains_one_uni 'block_type', PAbstractType, :lowerBound => 0
 
     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]
         else
           [0,0]
         end
       end
 
       def hash
         [self.class, Set.new(param_types), block_type].hash
       end
 
       def ==(o)
         self.class == o.class && args_type == o.args_type && block_type == o.block_type
       end
     end
   end
 
   # @api public
   class PArrayType < PCollectionType
     module ClassModule
       def hash
         [self.class, self.element_type, self.size_type].hash
       end
 
       def ==(o)
         self.class == o.class && self.element_type == o.element_type && self.size_type == o.size_type
       end
     end
   end
 
   # @api public
   class PHashType < PCollectionType
     contains_one_uni 'key_type', PAbstractType
     module ClassModule
       def hash
         [self.class, key_type, self.element_type, self.size_type].hash
       end
 
       def ==(o)
         self.class        == o.class         &&
         key_type          == o.key_type      &&
         self.element_type == o.element_type  &&
         self.size_type    == o.size_type
       end
     end
   end
 
   # @api public
   class PRubyType < PAnyType
     has_attr 'ruby_class', String
     module ClassModule
       def hash
         [self.class, ruby_class].hash
       end
 
       def ==(o)
         self.class == o.class && ruby_class == o.ruby_class
       end
     end
   end
 
   # Abstract representation of a type that can be placed in a Catalog.
   # @api public
   #
   class PCatalogEntryType < PAnyType
   end
 
   # Represents a (host-) class in the Puppet Language.
   # @api public
   #
   class PHostClassType < PCatalogEntryType
     has_attr 'class_name', String
     # contains_one_uni 'super_type', PHostClassType
     module ClassModule
       def hash
         [self.class, class_name].hash
       end
       def ==(o)
         self.class == o.class && class_name == o.class_name
       end
     end
   end
 
   # Represents a Resource Type in the Puppet Language
   # @api public
   #
   class PResourceType < PCatalogEntryType
     has_attr 'type_name', String
     has_attr 'title', String
     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
     end
   end
 
   # Represents a type that accept PNilType instead of the type parameter
   # required_type - is a short hand for Variant[T, Undef]
   #
   class POptionalType < PAbstractType
     contains_one_uni 'optional_type', PAbstractType
     module ClassModule
       def hash
         [self.class, optional_type].hash
       end
 
       def ==(o)
         self.class == o.class && optional_type == o.optional_type
       end
     end
   end
 
 end