diff --git a/lib/puppet/pops/types/type_factory.rb b/lib/puppet/pops/types/type_factory.rb
index d411fa5b2..743c7ddee 100644
--- a/lib/puppet/pops/types/type_factory.rb
+++ b/lib/puppet/pops/types/type_factory.rb
@@ -1,402 +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)
     if Puppet::Pops::Types::TypeCalculator.is_kind_of_callable?(params.last)
       last_callable = true
     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
+    if types.empty? && !size_type.nil? && size_type.range[1] > 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/spec/unit/pops/types/type_parser_spec.rb b/spec/unit/pops/types/type_parser_spec.rb
index 31bf006cf..0b7c9b6fc 100644
--- a/spec/unit/pops/types/type_parser_spec.rb
+++ b/spec/unit/pops/types/type_parser_spec.rb
@@ -1,232 +1,239 @@
 require 'spec_helper'
 require 'puppet/pops'
 
 describe Puppet::Pops::Types::TypeParser do
   extend RSpec::Matchers::DSL
 
   let(:parser) { Puppet::Pops::Types::TypeParser.new }
   let(:types)  { Puppet::Pops::Types::TypeFactory }
 
 
   it "rejects a puppet expression" do
     expect { parser.parse("1 + 1") }.to raise_error(Puppet::ParseError, /The expression <1 \+ 1> is not a valid type specification/)
   end
 
   it "rejects a empty type specification" do
     expect { parser.parse("") }.to raise_error(Puppet::ParseError, /The expression <> is not a valid type specification/)
   end
 
   it "rejects an invalid type simple type" do
     expect { parser.parse("notAType") }.to raise_error(Puppet::ParseError, /The expression <notAType> is not a valid type specification/)
   end
 
   it "rejects an unknown parameterized type" do
     expect { parser.parse("notAType[Integer]") }.to raise_error(Puppet::ParseError,
       /The expression <notAType\[Integer\]> is not a valid type specification/)
   end
 
   it "rejects an unknown type parameter" do
     expect { parser.parse("Array[notAType]") }.to raise_error(Puppet::ParseError,
       /The expression <Array\[notAType\]> is not a valid type specification/)
   end
 
   [
     'Any', 'Data', 'CatalogEntry', 'Boolean', 'Scalar', 'Undef', 'Numeric',
   ].each do |name|
     it "does not support parameterizing unparameterized type <#{name}>" do
       expect { parser.parse("#{name}[Integer]") }.to raise_unparameterized_error_for(name)
     end
   end
 
   it "parses a simple, unparameterized type into the type object" do
     expect(the_type_parsed_from(types.any)).to be_the_type(types.any)
     expect(the_type_parsed_from(types.integer)).to be_the_type(types.integer)
     expect(the_type_parsed_from(types.float)).to be_the_type(types.float)
     expect(the_type_parsed_from(types.string)).to be_the_type(types.string)
     expect(the_type_parsed_from(types.boolean)).to be_the_type(types.boolean)
     expect(the_type_parsed_from(types.pattern)).to be_the_type(types.pattern)
     expect(the_type_parsed_from(types.data)).to be_the_type(types.data)
     expect(the_type_parsed_from(types.catalog_entry)).to be_the_type(types.catalog_entry)
     expect(the_type_parsed_from(types.collection)).to be_the_type(types.collection)
     expect(the_type_parsed_from(types.tuple)).to be_the_type(types.tuple)
     expect(the_type_parsed_from(types.struct)).to be_the_type(types.struct)
     expect(the_type_parsed_from(types.optional)).to be_the_type(types.optional)
   end
 
   it "interprets an unparameterized Array as an Array of Data" do
     expect(parser.parse("Array")).to be_the_type(types.array_of_data)
   end
 
   it "interprets an unparameterized Hash as a Hash of Scalar to Data" do
     expect(parser.parse("Hash")).to be_the_type(types.hash_of_data)
   end
 
   it "interprets a parameterized Hash[t] as a Hash of Scalar to t" do
     expect(parser.parse("Hash[Integer]")).to be_the_type(types.hash_of(types.integer))
   end
 
   it "parses a parameterized type into the type object" do
     parameterized_array = types.array_of(types.integer)
     parameterized_hash = types.hash_of(types.integer, types.boolean)
 
     expect(the_type_parsed_from(parameterized_array)).to be_the_type(parameterized_array)
     expect(the_type_parsed_from(parameterized_hash)).to be_the_type(parameterized_hash)
   end
 
   it "parses a size constrained collection using capped range" do
     parameterized_array = types.array_of(types.integer)
     types.constrain_size(parameterized_array, 1,2)
     parameterized_hash = types.hash_of(types.integer, types.boolean)
     types.constrain_size(parameterized_hash, 1,2)
 
     expect(the_type_parsed_from(parameterized_array)).to be_the_type(parameterized_array)
     expect(the_type_parsed_from(parameterized_hash)).to be_the_type(parameterized_hash)
   end
 
   it "parses a size constrained collection with open range" do
     parameterized_array = types.array_of(types.integer)
     types.constrain_size(parameterized_array, 1,:default)
     parameterized_hash = types.hash_of(types.integer, types.boolean)
     types.constrain_size(parameterized_hash, 1,:default)
 
     expect(the_type_parsed_from(parameterized_array)).to be_the_type(parameterized_array)
     expect(the_type_parsed_from(parameterized_hash)).to be_the_type(parameterized_hash)
   end
 
   it "parses optional type" do
     opt_t = types.optional(Integer)
     expect(the_type_parsed_from(opt_t)).to be_the_type(opt_t)
   end
 
   it "parses tuple type" do
     tuple_t = types.tuple(Integer, String)
     expect(the_type_parsed_from(tuple_t)).to be_the_type(tuple_t)
   end
 
   it "parses tuple type with occurence constraint" do
     tuple_t = types.tuple(Integer, String)
     types.constrain_size(tuple_t, 2, 5)
     expect(the_type_parsed_from(tuple_t)).to be_the_type(tuple_t)
   end
 
   it "parses struct type" do
     struct_t = types.struct({'a'=>Integer, 'b'=>String})
     expect(the_type_parsed_from(struct_t)).to be_the_type(struct_t)
   end
 
   describe "handles parsing of patterns and regexp" do
     { 'Pattern[/([a-z]+)([1-9]+)/]'        => [:pattern, [/([a-z]+)([1-9]+)/]],
       'Pattern["([a-z]+)([1-9]+)"]'        => [:pattern, [/([a-z]+)([1-9]+)/]],
       'Regexp[/([a-z]+)([1-9]+)/]'         => [:regexp,  [/([a-z]+)([1-9]+)/]],
       'Pattern[/x9/, /([a-z]+)([1-9]+)/]'  => [:pattern, [/x9/, /([a-z]+)([1-9]+)/]],
     }.each do |source, type|
       it "such that the source '#{source}' yields the type #{type.to_s}" do
         expect(parser.parse(source)).to be_the_type(Puppet::Pops::Types::TypeFactory.send(type[0], *type[1]))
       end
     end
   end
 
   it "rejects an collection spec with the wrong number of parameters" do
     expect { parser.parse("Array[Integer, 1,2,3]") }.to raise_the_parameter_error("Array", "1 to 3", 4)
     expect { parser.parse("Hash[Integer, Integer, 1,2,3]") }.to raise_the_parameter_error("Hash", "1 to 4", 5)
   end
 
   it "interprets anything that is not a built in type to be a resource type" do
     expect(parser.parse("File")).to be_the_type(types.resource('file'))
   end
 
   it "parses a resource type with title" do
     expect(parser.parse("File['/tmp/foo']")).to be_the_type(types.resource('file', '/tmp/foo'))
   end
 
   it "parses a resource type using 'Resource[type]' form" do
     expect(parser.parse("Resource[File]")).to be_the_type(types.resource('file'))
   end
 
   it "parses a resource type with title using 'Resource[type, title]'" do
     expect(parser.parse("Resource[File, '/tmp/foo']")).to be_the_type(types.resource('file', '/tmp/foo'))
   end
 
   it "parses a host class type" do
     expect(parser.parse("Class")).to be_the_type(types.host_class())
   end
 
   it "parses a parameterized host class type" do
     expect(parser.parse("Class[foo::bar]")).to be_the_type(types.host_class('foo::bar'))
   end
 
   it 'parses an integer range' do
    expect(parser.parse("Integer[1,2]")).to be_the_type(types.range(1,2))
   end
 
   it 'parses a float range' do
    expect(parser.parse("Float[1.0,2.0]")).to be_the_type(types.float_range(1.0,2.0))
   end
 
   it 'parses a collection size range' do
    expect(parser.parse("Collection[1,2]")).to be_the_type(types.constrain_size(types.collection,1,2))
   end
 
   it 'parses a type type' do
     expect(parser.parse("Type[Integer]")).to be_the_type(types.type_type(types.integer))
   end
 
   it 'parses a ruby type' do
     expect(parser.parse("Ruby['Integer']")).to be_the_type(types.ruby_type('Integer'))
   end
 
   it 'parses a callable type' do
     expect(parser.parse("Callable")).to be_the_type(types.all_callables())
   end
 
   it 'parses a parameterized callable type' do
     expect(parser.parse("Callable[String, Integer]")).to be_the_type(types.callable(String, Integer))
   end
 
   it 'parses a parameterized callable type with min/max' do
     expect(parser.parse("Callable[String, Integer, 1, default]")).to be_the_type(types.callable(String, Integer, 1, :default))
   end
 
   it 'parses a parameterized callable type with block' do
     expect(parser.parse("Callable[String, Callable[Boolean]]")).to be_the_type(types.callable(String, types.callable(true)))
   end
 
-  it 'parses a parameterized callable type with only min/max' do
+  it 'parses a parameterized callable type with 0 min/max' do
     t = parser.parse("Callable[0,0]")
     expect(t).to be_the_type(types.callable())
     expect(t.param_types.types).to be_empty
   end
 
+  it 'parses a parameterized callable type with >0 min/max' do
+    t = parser.parse("Callable[0,1]")
+    expect(t).to be_the_type(types.callable(0,1))
+    # Contains a Unit type to indicate "called with what you accept"
+    expect(t.param_types.types[0]).to be_the_type(Puppet::Pops::Types::PUnitType.new())
+  end
+
   matcher :be_the_type do |type|
     calc = Puppet::Pops::Types::TypeCalculator.new
 
     match do |actual|
       calc.assignable?(actual, type) && calc.assignable?(type, actual)
     end
 
     failure_message_for_should do |actual|
       "expected #{calc.string(type)}, but was #{calc.string(actual)}"
     end
   end
 
   def raise_the_parameter_error(type, required, given)
     raise_error(Puppet::ParseError, /#{type} requires #{required}, #{given} provided/)
   end
 
   def raise_type_error_for(type_name)
     raise_error(Puppet::ParseError, /Unknown type <#{type_name}>/)
   end
 
   def raise_unparameterized_error_for(type_name)
     raise_error(Puppet::ParseError, /Not a parameterized type <#{type_name}>/)
   end
 
   def the_type_parsed_from(type)
     parser.parse(the_type_spec_for(type))
   end
 
   def the_type_spec_for(type)
     calc = Puppet::Pops::Types::TypeCalculator.new
     calc.string(type)
   end
 end