puppet 4.3.2 → 4.4.0

data/spec/unit/pops/types/type_asserter_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+require 'puppet/pops'
+
+module Puppet::Pops::Types
+describe 'the type asserter' do
+  let!(:asserter) { TypeAsserter }
+
+  context 'when deferring formatting of subject'
+  it 'can use an array' do
+    expect{ asserter.assert_instance_of(['The %s in the %s', 'gizmo', 'gadget'], PIntegerType::DEFAULT, 'lens') }.to(
+    raise_error(TypeAssertionError, 'The gizmo in the gadget has wrong type, expected an Integer value, got String'))
+  end
+
+  it 'can use an array obtained from block' do
+    expect do
+      asserter.assert_instance_of('gizmo', PIntegerType::DEFAULT, 'lens') { |s| ['The %s in the %s', s, 'gadget'] }
+    end.to(raise_error(TypeAssertionError, 'The gizmo in the gadget has wrong type, expected an Integer value, got String'))
+  end
+
+  it 'can use an subject obtained from zero argument block' do
+    expect do
+      asserter.assert_instance_of(nil, PIntegerType::DEFAULT, 'lens') { 'The gizmo in the gadget' }
+    end.to(raise_error(TypeAssertionError, 'The gizmo in the gadget has wrong type, expected an Integer value, got String'))
+  end
+
+  it 'does not produce a string unless the assertion fails' do
+    TypeAsserter.expects(:report_type_mismatch).never
+    asserter.assert_instance_of(nil, PIntegerType::DEFAULT, 1)
+  end
+
+  it 'does not format string unless the assertion fails' do
+    fmt_string = 'The %s in the %s'
+    fmt_string.expects(:'%').never
+    asserter.assert_instance_of([fmt_string, 'gizmo', 'gadget'], PIntegerType::DEFAULT, 1)
+  end
+
+  it 'does not call block unless the assertion fails' do
+    expect do
+      asserter.assert_instance_of(nil, PIntegerType::DEFAULT, 1) { |s| raise Error }
+    end.not_to raise_error
+  end
+end
+end

data/spec/unit/pops/types/type_calculator_spec.rb

@@ -40,6 +40,15 @@ describe 'The type calculator' do
     Puppet::Pops::Types::TypeFactory.variant(*types)
   end
 
+  def type_alias_t(name, type_string)
+    type_expr = Puppet::Pops::Parser::EvaluatingParser.new.parse_string(type_string).current
+    Puppet::Pops::Types::TypeFactory.type_alias(name, type_expr)
+  end
+
+  def type_reference_t(name, *args)
+    Puppet::Pops::Types::TypeFactory.type_reference(name, args)
+  end
+
   def integer_t
     Puppet::Pops::Types::TypeFactory.integer
   end
@@ -88,6 +97,10 @@ describe 'The type calculator' do
     Puppet::Pops::Types::TypeFactory.optional(t)
   end
 
+  def type_t(t)
+    Puppet::Pops::Types::TypeFactory.type_type(t)
+  end
+
   def not_undef_t(t = nil)
     Puppet::Pops::Types::TypeFactory.not_undef(t)
   end
@@ -105,99 +118,6 @@ describe 'The type calculator' do
     Puppet::Pops::Types
   end
 
-  shared_context 'types_setup' do
-
-    # Do not include the special type Unit in this list
-    def all_types
-      [ Puppet::Pops::Types::PAnyType,
-        Puppet::Pops::Types::PUndefType,
-        Puppet::Pops::Types::PNotUndefType,
-        Puppet::Pops::Types::PDataType,
-        Puppet::Pops::Types::PScalarType,
-        Puppet::Pops::Types::PStringType,
-        Puppet::Pops::Types::PNumericType,
-        Puppet::Pops::Types::PIntegerType,
-        Puppet::Pops::Types::PFloatType,
-        Puppet::Pops::Types::PRegexpType,
-        Puppet::Pops::Types::PBooleanType,
-        Puppet::Pops::Types::PCollectionType,
-        Puppet::Pops::Types::PArrayType,
-        Puppet::Pops::Types::PHashType,
-        Puppet::Pops::Types::PRuntimeType,
-        Puppet::Pops::Types::PHostClassType,
-        Puppet::Pops::Types::PResourceType,
-        Puppet::Pops::Types::PPatternType,
-        Puppet::Pops::Types::PEnumType,
-        Puppet::Pops::Types::PVariantType,
-        Puppet::Pops::Types::PStructType,
-        Puppet::Pops::Types::PTupleType,
-        Puppet::Pops::Types::PCallableType,
-        Puppet::Pops::Types::PType,
-        Puppet::Pops::Types::POptionalType,
-        Puppet::Pops::Types::PDefaultType,
-      ]
-    end
-
-    def scalar_types
-      # PVariantType is also scalar, if its types are all Scalar
-      [
-        Puppet::Pops::Types::PScalarType,
-        Puppet::Pops::Types::PStringType,
-        Puppet::Pops::Types::PNumericType,
-        Puppet::Pops::Types::PIntegerType,
-        Puppet::Pops::Types::PFloatType,
-        Puppet::Pops::Types::PRegexpType,
-        Puppet::Pops::Types::PBooleanType,
-        Puppet::Pops::Types::PPatternType,
-        Puppet::Pops::Types::PEnumType,
-      ]
-    end
-
-    def numeric_types
-      # PVariantType is also numeric, if its types are all numeric
-      [
-        Puppet::Pops::Types::PNumericType,
-        Puppet::Pops::Types::PIntegerType,
-        Puppet::Pops::Types::PFloatType,
-      ]
-    end
-
-    def string_types
-      # PVariantType is also string type, if its types are all compatible
-      [
-        Puppet::Pops::Types::PStringType,
-        Puppet::Pops::Types::PPatternType,
-        Puppet::Pops::Types::PEnumType,
-      ]
-    end
-
-    def collection_types
-      # PVariantType is also string type, if its types are all compatible
-      [
-        Puppet::Pops::Types::PCollectionType,
-        Puppet::Pops::Types::PHashType,
-        Puppet::Pops::Types::PArrayType,
-        Puppet::Pops::Types::PStructType,
-        Puppet::Pops::Types::PTupleType,
-      ]
-    end
-
-    def data_compatible_types
-      result = scalar_types
-      result << Puppet::Pops::Types::PDataType
-      result << array_t(types::PDataType::DEFAULT)
-      result << types::TypeFactory.hash_of_data
-      result << Puppet::Pops::Types::PUndefType
-      result << not_undef_t(types::PDataType.new)
-      result << constrained_tuple_t(range_t(0, nil), types::PDataType::DEFAULT)
-      result
-    end
-
-    def type_from_class(c)
-      c.is_a?(Class) ? c::DEFAULT : c
-    end
-  end
-
   context 'when inferring ruby' do
 
     it 'fixnum translates to PIntegerType' do
@@ -234,12 +154,16 @@ describe 'The type calculator' do
       expect(calculator.infer(/^a regular expression$/).class).to eq(Puppet::Pops::Types::PRegexpType)
     end
 
+    it 'iterable translates to PIteratorType' do
+      expect(calculator.infer(Puppet::Pops::Types::Iterable.on(1))).to be_a(Puppet::Pops::Types::PIteratorType)
+    end
+
     it 'nil translates to PUndefType' do
       expect(calculator.infer(nil).class).to eq(Puppet::Pops::Types::PUndefType)
     end
 
-    it ':undef translates to PRuntimeType' do
-      expect(calculator.infer(:undef).class).to eq(Puppet::Pops::Types::PRuntimeType)
+    it ':undef translates to PUndefType' do
+      expect(calculator.infer(:undef).class).to eq(Puppet::Pops::Types::PUndefType)
     end
 
     it 'an instance of class Foo translates to PRuntimeType[ruby, Foo]' do
@@ -455,35 +379,35 @@ describe 'The type calculator' do
     it 'computes given resource type commonality' do
       r1 = Puppet::Pops::Types::PResourceType.new('File', nil)
       r2 = Puppet::Pops::Types::PResourceType.new('File', nil)
-      expect(calculator.string(calculator.common_type(r1, r2))).to eq('File')
+      expect(calculator.common_type(r1, r2).to_s).to eq('File')
 
 
       r2 = Puppet::Pops::Types::PResourceType.new('File', '/tmp/foo')
-      expect(calculator.string(calculator.common_type(r1, r2))).to eq('File')
+      expect(calculator.common_type(r1, r2).to_s).to eq('File')
 
       r1 = Puppet::Pops::Types::PResourceType.new('File', '/tmp/foo')
-      expect(calculator.string(calculator.common_type(r1, r2))).to eq("File['/tmp/foo']")
+      expect(calculator.common_type(r1, r2).to_s).to eq("File['/tmp/foo']")
 
       r1 = Puppet::Pops::Types::PResourceType.new('File', '/tmp/bar')
-      expect(calculator.string(calculator.common_type(r1, r2))).to eq('File')
+      expect(calculator.common_type(r1, r2).to_s).to eq('File')
 
       r2 = Puppet::Pops::Types::PResourceType.new('Package', 'apache')
-      expect(calculator.string(calculator.common_type(r1, r2))).to eq('Resource')
+      expect(calculator.common_type(r1, r2).to_s).to eq('Resource')
     end
 
     it 'computes given hostclass type commonality' do
       r1 = Puppet::Pops::Types::PHostClassType.new('foo')
       r2 = Puppet::Pops::Types::PHostClassType.new('foo')
-      expect(calculator.string(calculator.common_type(r1, r2))).to eq('Class[foo]')
+      expect(calculator.common_type(r1, r2).to_s).to eq('Class[foo]')
 
       r2 = Puppet::Pops::Types::PHostClassType.new('bar')
-      expect(calculator.string(calculator.common_type(r1, r2))).to eq('Class')
+      expect(calculator.common_type(r1, r2).to_s).to eq('Class')
 
       r2 = Puppet::Pops::Types::PHostClassType.new(nil)
-      expect(calculator.string(calculator.common_type(r1, r2))).to eq('Class')
+      expect(calculator.common_type(r1, r2).to_s).to eq('Class')
 
       r1 = Puppet::Pops::Types::PHostClassType.new(nil)
-      expect(calculator.string(calculator.common_type(r1, r2))).to eq('Class')
+      expect(calculator.common_type(r1, r2).to_s).to eq('Class')
     end
 
     context 'of strings' do
@@ -526,7 +450,7 @@ describe 'The type calculator' do
       common_t = calculator.common_type(t1,t2)
       expect(common_t.class).to eq(Puppet::Pops::Types::PPatternType)
       expect(common_t.patterns.map { |pr| pr.pattern }).to eq(['abc', 'xyz'])
-      expect(calculator.string(common_t)).to eq('Pattern[/abc/, /xyz/]')
+      expect(common_t.to_s).to eq('Pattern[/abc/, /xyz/]')
     end
 
     it 'computes enum commonality to value set sum' do
@@ -686,6 +610,36 @@ describe 'The type calculator' do
       end
     end
 
+    context "for TypeReference, such that" do
+      it 'no other type is assignable' do
+        t = Puppet::Pops::Types::PTypeReferenceType::DEFAULT
+        all_instances = (all_types - [
+          Puppet::Pops::Types::PTypeReferenceType, # Avoid comparison with t
+          Puppet::Pops::Types::PVariantType,   # DEFAULT contains no variants, so assignability is never tested and always true
+          Puppet::Pops::Types::PTypeAliasType      # DEFAULT resolves to PTypeReferenceType::DEFAULT, i.e. t
+        ]).map {|c| c::DEFAULT }
+
+        # Add a non-empty variant
+        all_instances << variant_t(Puppet::Pops::Types::PAnyType::DEFAULT)
+        # Add a type alias that doesn't resolve to 't'
+        all_instances << type_alias_t('MyInt', 'Integer').resolve(Puppet::Pops::Types::TypeParser.new, nil)
+
+        all_instances.each { |i| expect(i).not_to be_assignable_to(t) }
+      end
+
+      it 'a TypeReference to the exact same type is assignable' do
+        expect(type_reference_t('Integer[0,10]')).to be_assignable_to(type_reference_t('Integer[0,10]'))
+      end
+
+      it 'a TypeReference to the different type is not assignable' do
+        expect(type_reference_t('String')).not_to be_assignable_to(type_reference_t('Integer'))
+      end
+
+      it 'a TypeReference to the different type is not assignable even if the referenced type is' do
+        expect(type_reference_t('Integer[1,2]')).not_to be_assignable_to(type_reference_t('Integer[0,3]'))
+      end
+    end
+
     context 'for Data, such that' do
       it 'all scalars + array and hash are assignable to Data' do
         t = Puppet::Pops::Types::PDataType::DEFAULT
@@ -793,7 +747,11 @@ describe 'The type calculator' do
       end
 
       it 'Collection is not assignable to any disjunct type' do
-        tested_types = all_types - [Puppet::Pops::Types::PAnyType, Puppet::Pops::Types::POptionalType, Puppet::Pops::Types::PNotUndefType] - collection_types
+        tested_types = all_types - [
+          Puppet::Pops::Types::PAnyType,
+          Puppet::Pops::Types::POptionalType,
+          Puppet::Pops::Types::PNotUndefType,
+          Puppet::Pops::Types::PIterableType] - collection_types
         t = Puppet::Pops::Types::PCollectionType::DEFAULT
         tested_types.each {|t2| expect(t).not_to be_assignable_to(t2::DEFAULT) }
       end
@@ -815,6 +773,7 @@ describe 'The type calculator' do
           Puppet::Pops::Types::PAnyType,
           Puppet::Pops::Types::POptionalType,
           Puppet::Pops::Types::PNotUndefType,
+          Puppet::Pops::Types::PIterableType,
           Puppet::Pops::Types::PDataType] - collection_types
         t = Puppet::Pops::Types::PArrayType::DEFAULT
         tested_types.each {|t2| expect(t).not_to be_assignable_to(t2::DEFAULT) }
@@ -841,6 +800,7 @@ describe 'The type calculator' do
           Puppet::Pops::Types::PAnyType,
           Puppet::Pops::Types::POptionalType,
           Puppet::Pops::Types::PNotUndefType,
+          Puppet::Pops::Types::PIterableType,
           Puppet::Pops::Types::PDataType] - collection_types
         t = Puppet::Pops::Types::PHashType::DEFAULT
         tested_types.each {|t2| expect(t).not_to be_assignable_to(t2::DEFAULT) }
@@ -878,6 +838,7 @@ describe 'The type calculator' do
           Puppet::Pops::Types::PAnyType,
           Puppet::Pops::Types::POptionalType,
           Puppet::Pops::Types::PNotUndefType,
+          Puppet::Pops::Types::PIterableType,
           Puppet::Pops::Types::PDataType] - collection_types
         t = Puppet::Pops::Types::PTupleType::DEFAULT
         tested_types.each {|t2| expect(t).not_to be_assignable_to(t2::DEFAULT) }
@@ -899,6 +860,7 @@ describe 'The type calculator' do
           Puppet::Pops::Types::PAnyType,
           Puppet::Pops::Types::POptionalType,
           Puppet::Pops::Types::PNotUndefType,
+          Puppet::Pops::Types::PIterableType,
           Puppet::Pops::Types::PDataType] - collection_types
         t = Puppet::Pops::Types::PStructType::DEFAULT
         tested_types.each {|t2| expect(t).not_to be_assignable_to(t2::DEFAULT) }
@@ -1323,6 +1285,122 @@ describe 'The type calculator' do
       expect(calculator.assignable?(r1, r2)).to eq(false)
     end
 
+    context 'for TypeAlias, such that' do
+      let!(:parser) { Puppet::Pops::Types::TypeParser.new }
+
+      it 'it is assignable to the type that it is an alias for' do
+        t = type_alias_t('Alias', 'Integer').resolve(parser, nil)
+        expect(calculator.assignable?(integer_t, t)).to be_truthy
+      end
+
+      it 'the type that it is an alias for is assignable to it' do
+        t = type_alias_t('Alias', 'Integer').resolve(parser, nil)
+        expect(calculator.assignable?(t, integer_t)).to be_truthy
+      end
+
+      it 'a recursive alias can be assignable from a conformant type with any depth' do
+        scope = mock
+
+        t = type_alias_t('Tree', 'Hash[String,Variant[String,Tree]]')
+        loader = mock
+        loader.expects(:load).with(:type, 'tree').returns t
+
+        Puppet::Pops::Adapters::LoaderAdapter.expects(:loader_for_model_object).with(instance_of(Puppet::Pops::Model::QualifiedReference), scope).at_most_once.returns loader
+
+        t.resolve(parser, scope)
+        expect(calculator.assignable?(t, parser.parse('Hash[String,Variant[String,Hash[String,Variant[String,String]]]]'))).to be_truthy
+      end
+
+
+      it 'similar recursive aliases are assignable' do
+        scope = mock
+
+        t1 = type_alias_t('Tree1', 'Hash[String,Variant[String,Tree1]]')
+        t2 = type_alias_t('Tree2', 'Hash[String,Variant[String,Tree2]]')
+        loader = mock
+        loader.expects(:load).with(:type, 'tree1').returns t1
+        loader.expects(:load).with(:type, 'tree2').returns t2
+
+        Puppet::Pops::Adapters::LoaderAdapter.expects(:loader_for_model_object).with(instance_of(Puppet::Pops::Model::QualifiedReference), scope).at_least_once.returns loader
+
+        t1.resolve(parser, scope)
+        t2.resolve(parser, scope)
+        expect(calculator.assignable?(t1, t2)).to be_truthy
+      end
+
+      it 'crossing recursive aliases are assignable' do
+        scope = mock
+
+        t1 = type_alias_t('Tree1', 'Hash[String,Variant[String,Tree2]]')
+        t2 = type_alias_t('Tree2', 'Hash[String,Variant[String,Tree1]]')
+        loader = mock
+        loader.expects(:load).with(:type, 'tree1').returns t1
+        loader.expects(:load).with(:type, 'tree2').returns t2
+        loader.expects(:is_a?).with(Puppet::Pops::Loader::Loader).returns true
+
+        Puppet::Pops::Adapters::LoaderAdapter.expects(:loader_for_model_object).with(instance_of(Puppet::Pops::Model::QualifiedReference), scope).at_least_once.returns loader
+
+        t1.resolve(parser, scope)
+        t2.resolve(parser, scope)
+        expect(calculator.assignable?(t1, t2)).to be_truthy
+      end
+
+      it 'Type[T] is assignable to Type[AT] when AT is an alias for T' do
+        scope = mock
+
+        ta = type_alias_t('PositiveInteger', 'Integer[0,default]')
+        loader = mock
+        loader.expects(:load).with(:type, 'positiveinteger').returns ta
+        Puppet::Pops::Adapters::LoaderAdapter.expects(:loader_for_model_object)
+          .with(instance_of(Puppet::Pops::Model::QualifiedReference), scope).returns loader
+
+        t1 = type_t(range_t(0, :default))
+        t2 = parser.parse('Type[PositiveInteger]', scope)
+        expect(calculator.assignable?(t2, t1)).to be_truthy
+      end
+
+      it 'Type[T] is assignable to AT when AT is an alias for Type[T]' do
+        scope = mock
+
+        ta = type_alias_t('PositiveIntegerType', 'Type[Integer[0,default]]')
+        loader = mock
+        loader.expects(:load).with(:type, 'positiveintegertype').returns ta
+        Puppet::Pops::Adapters::LoaderAdapter.expects(:loader_for_model_object)
+          .with(instance_of(Puppet::Pops::Model::QualifiedReference), scope).returns loader
+
+        t1 = type_t(range_t(0, :default))
+        t2 = parser.parse('PositiveIntegerType', scope)
+        expect(calculator.assignable?(t2, t1)).to be_truthy
+      end
+
+      it 'Type[Type[T]] is assignable to Type[Type[AT]] when AT is an alias for T' do
+        scope = mock
+
+        ta = type_alias_t('PositiveInteger', 'Integer[0,default]')
+        loader = mock
+        loader.expects(:load).with(:type, 'positiveinteger').returns ta
+        Puppet::Pops::Adapters::LoaderAdapter.expects(:loader_for_model_object)
+          .with(instance_of(Puppet::Pops::Model::QualifiedReference), scope).returns loader
+
+        t1 = type_t(type_t(range_t(0, :default)))
+        t2 = parser.parse('Type[Type[PositiveInteger]]', scope)
+        expect(calculator.assignable?(t2, t1)).to be_truthy
+      end
+
+      it 'Type[Type[T]] is assignable to Type[AT] when AT is an alias for Type[T]' do
+        scope = mock
+
+        ta = type_alias_t('PositiveIntegerType', 'Type[Integer[0,default]]')
+        loader = mock
+        loader.expects(:load).with(:type, 'positiveintegertype').returns ta
+        Puppet::Pops::Adapters::LoaderAdapter.expects(:loader_for_model_object)
+          .with(instance_of(Puppet::Pops::Model::QualifiedReference), scope).returns loader
+
+        t1 = type_t(type_t(range_t(0, :default)))
+        t2 = parser.parse('Type[PositiveIntegerType]', scope)
+        expect(calculator.assignable?(t2, t1)).to be_truthy
+      end
+    end
   end
 
   context 'when testing if x is instance of type t' do
@@ -1340,8 +1418,16 @@ describe 'The type calculator' do
       end
     end
 
-    it "should consider :undef to be instance of Runtime['ruby', 'Symbol]" do
-      expect(calculator.instance?(Puppet::Pops::Types::PRuntimeType.new(:ruby, 'Symbol'), :undef)).to eq(true)
+    it "should infer :undef to be Undef" do
+      expect(calculator.infer(:undef)).to be_assignable_to(undef_t)
+    end
+
+    it "should not consider :default to be instance of Runtime['ruby', 'Symbol]" do
+      expect(calculator.instance?(Puppet::Pops::Types::PRuntimeType.new(:ruby, 'Symbol'), :default)).to eq(false)
+    end
+
+    it "should not consider :undef to be instance of Runtime['ruby', 'Symbol]" do
+      expect(calculator.instance?(Puppet::Pops::Types::PRuntimeType.new(:ruby, 'Symbol'), :undef)).to eq(false)
     end
 
     it 'should consider :undef to be instance of an Optional type' do
@@ -1591,6 +1677,49 @@ describe 'The type calculator' do
         expect(calculator.instance?(callable_t(String), f)).to be_truthy
       end
     end
+
+    context 'and t is a TypeAlias' do
+      let!(:parser) { Puppet::Pops::Types::TypeParser.new }
+
+      it 'should consider x an instance of the aliased simple type' do
+        t = type_alias_t('Alias', 'Integer').resolve(parser, nil)
+        expect(calculator.instance?(t, 15)).to be_truthy
+      end
+
+      it 'should consider x an instance of the aliased parameterized type' do
+        t = type_alias_t('Alias', 'Integer[0,20]').resolve(parser, nil)
+        expect(calculator.instance?(t, 15)).to be_truthy
+      end
+
+      it 'should consider x an instance of the aliased type that uses self recursion' do
+        scope = mock
+
+        t = type_alias_t('Tree', 'Hash[String,Variant[String,Tree]]')
+        loader = mock
+        loader.expects(:load).with(:type, 'tree').returns t
+
+        Puppet::Pops::Adapters::LoaderAdapter.expects(:loader_for_model_object).with(instance_of(Puppet::Pops::Model::QualifiedReference), scope).at_most_once.returns loader
+
+        t.resolve(parser, scope)
+        expect(calculator.instance?(t, {'a'=>{'aa'=>{'aaa'=>'aaaa'}}, 'b'=>'bb'})).to be_truthy
+      end
+
+      it 'should consider x an instance of the aliased type that uses contains an alias that causes self recursion' do
+        scope = mock
+
+        t1 = type_alias_t('Tree', 'Hash[String,Variant[String,OtherTree]]')
+        t2 = type_alias_t('OtherTree', 'Hash[String,Tree]')
+        loader = mock
+        loader.expects(:load).with(:type, 'tree').returns t1
+        loader.expects(:load).with(:type, 'othertree').returns t2
+        loader.expects(:is_a?).with(Puppet::Pops::Loader::Loader).returns true
+
+        Puppet::Pops::Adapters::LoaderAdapter.expects(:loader_for_model_object).with(instance_of(Puppet::Pops::Model::QualifiedReference), scope).at_least_once.returns loader
+
+        t1.resolve(parser, scope)
+        expect(calculator.instance?(t1, {'a'=>{'aa'=>{'aaa'=>'aaaa'}}, 'b'=>'bb'})).to be_truthy
+      end
+    end
   end
 
   context 'when converting a ruby class' do
@@ -1636,235 +1765,6 @@ describe 'The type calculator' do
     end
   end
 
-  context 'when representing the type as string' do
-    it 'should yield \'Type\' for PType' do
-      expect(calculator.string(Puppet::Pops::Types::PType::DEFAULT)).to eq('Type')
-    end
-
-    it 'should yield \'Object\' for PAnyType' do
-      expect(calculator.string(Puppet::Pops::Types::PAnyType::DEFAULT)).to eq('Any')
-    end
-
-    it 'should yield \'Scalar\' for PScalarType' do
-      expect(calculator.string(Puppet::Pops::Types::PScalarType::DEFAULT)).to eq('Scalar')
-    end
-
-    it 'should yield \'Boolean\' for PBooleanType' do
-      expect(calculator.string(Puppet::Pops::Types::PBooleanType::DEFAULT)).to eq('Boolean')
-    end
-
-    it 'should yield \'Data\' for PDataType' do
-      expect(calculator.string(Puppet::Pops::Types::PDataType::DEFAULT)).to eq('Data')
-    end
-
-    it 'should yield \'Numeric\' for PNumericType' do
-      expect(calculator.string(Puppet::Pops::Types::PNumericType::DEFAULT)).to eq('Numeric')
-    end
-
-    it 'should yield \'Integer\' and from/to for PIntegerType' do
-      int_T = Puppet::Pops::Types::PIntegerType
-      expect(calculator.string(int_T::DEFAULT)).to eq('Integer')
-      int = int_T.new(1, 1)
-      expect(calculator.string(int)).to eq('Integer[1, 1]')
-      int = int_T.new(1, 2)
-      expect(calculator.string(int)).to eq('Integer[1, 2]')
-      int = int_T.new(nil, 2)
-      expect(calculator.string(int)).to eq('Integer[default, 2]')
-      int = int_T.new(2, nil)
-      expect(calculator.string(int)).to eq('Integer[2, default]')
-    end
-
-    it 'should yield \'Float\' for PFloatType' do
-      expect(calculator.string(Puppet::Pops::Types::PFloatType::DEFAULT)).to eq('Float')
-    end
-
-    it 'should yield \'Regexp\' for PRegexpType' do
-      expect(calculator.string(Puppet::Pops::Types::PRegexpType::DEFAULT)).to eq('Regexp')
-    end
-
-    it 'should yield \'Regexp[/pat/]\' for parameterized PRegexpType' do
-      t = Puppet::Pops::Types::PRegexpType.new('a/b')
-      expect(calculator.string(t)).to eq('Regexp[/a\/b/]')
-    end
-
-    it 'should yield \'String\' for PStringType' do
-      expect(calculator.string(Puppet::Pops::Types::PStringType::DEFAULT)).to eq('String')
-    end
-
-    it 'should yield \'String\' for PStringType with multiple values' do
-      expect(calculator.string(string_t('a', 'b', 'c'))).to eq('String')
-    end
-
-    it 'should yield \'String\' and from/to for PStringType' do
-      string_T = Puppet::Pops::Types::PStringType
-      expect(calculator.string(string_T.new(range_t(1,1)))).to eq('String[1, 1]')
-      expect(calculator.string(string_T.new(range_t(1,2)))).to eq('String[1, 2]')
-      expect(calculator.string(string_T.new(range_t(:default, 2)))).to eq('String[default, 2]')
-      expect(calculator.string(string_T.new(range_t(2, :default)))).to eq('String[2, default]')
-    end
-
-    it 'should yield \'Array[Integer]\' for PArrayType[PIntegerType]' do
-      t = Puppet::Pops::Types::PArrayType.new(Puppet::Pops::Types::PIntegerType::DEFAULT)
-      expect(calculator.string(t)).to eq('Array[Integer]')
-    end
-
-    it 'should yield \'Array[Unit, 0, 0]\' for an empty array' do
-      t = empty_array_t
-      expect(calculator.string(t)).to eq('Array[Unit, 0, 0]')
-    end
-
-    it 'should yield \'Collection\' and from/to for PCollectionType' do
-      expect(calculator.string(collection_t(range_t(1,1)))).to eq('Collection[1, 1]')
-      expect(calculator.string(collection_t(range_t(1,2)))).to eq('Collection[1, 2]')
-      expect(calculator.string(collection_t(range_t(:default, 2)))).to eq('Collection[default, 2]')
-      expect(calculator.string(collection_t(range_t(2, :default)))).to eq('Collection[2, default]')
-    end
-
-    it 'should yield \'Array\' and from/to for PArrayType' do
-      expect(calculator.string(array_t(string_t, range_t(1,1)))).to eq('Array[String, 1, 1]')
-      expect(calculator.string(array_t(string_t, range_t(1,2)))).to eq('Array[String, 1, 2]')
-      expect(calculator.string(array_t(string_t, range_t(:default, 2)))).to eq('Array[String, default, 2]')
-      expect(calculator.string(array_t(string_t, range_t(2, :default)))).to eq('Array[String, 2, default]')
-    end
-
-    it 'should yield \'Tuple[Integer]\' for PTupleType[PIntegerType]' do
-      t = Puppet::Pops::Types::PTupleType.new([Puppet::Pops::Types::PIntegerType::DEFAULT])
-      expect(calculator.string(t)).to eq('Tuple[Integer]')
-    end
-
-    it 'should yield \'Tuple[T, T,..]\' for PTupleType[T, T, ...]' do
-      t = Puppet::Pops::Types::PTupleType.new([Puppet::Pops::Types::PIntegerType::DEFAULT, Puppet::Pops::Types::PIntegerType::DEFAULT, Puppet::Pops::Types::PStringType::DEFAULT])
-      expect(calculator.string(t)).to eq('Tuple[Integer, Integer, String]')
-    end
-
-    it 'should yield \'Tuple\' and from/to for PTupleType' do
-      expect(calculator.string(constrained_tuple_t(range_t(1,1), string_t))).to eq('Tuple[String, 1, 1]')
-      expect(calculator.string(constrained_tuple_t(range_t(1,2), string_t))).to eq('Tuple[String, 1, 2]')
-      expect(calculator.string(constrained_tuple_t(range_t(:default, 2), string_t))).to eq('Tuple[String, 0, 2]')
-      expect(calculator.string(constrained_tuple_t(range_t(2, :default), string_t))).to eq('Tuple[String, 2, default]')
-    end
-
-    it 'should yield \'Struct\' and details for PStructType' do
-      struct_t = struct_t({'a'=>Integer, 'b'=>String})
-      expect(calculator.string(struct_t)).to eq("Struct[{'a'=>Integer, 'b'=>String}]")
-      struct_t = struct_t({})
-      expect(calculator.string(struct_t)).to eq('Struct')
-    end
-
-    it 'should yield \'Hash[String, Integer]\' for PHashType[PStringType, PIntegerType]' do
-      t = Puppet::Pops::Types::PHashType.new(Puppet::Pops::Types::PStringType::DEFAULT, Puppet::Pops::Types::PIntegerType::DEFAULT)
-      expect(calculator.string(t)).to eq('Hash[String, Integer]')
-    end
-
-    it 'should yield \'Hash\' and from/to for PHashType' do
-      expect(calculator.string(hash_t(string_t, string_t, range_t(1,1)))).to eq('Hash[String, String, 1, 1]')
-      expect(calculator.string(hash_t(string_t, string_t, range_t(1,2)))).to eq('Hash[String, String, 1, 2]')
-      expect(calculator.string(hash_t(string_t, string_t, range_t(:default, 2)))).to eq('Hash[String, String, default, 2]')
-      expect(calculator.string(hash_t(string_t, string_t, range_t(2, :default)))).to eq('Hash[String, String, 2, default]')
-    end
-
-    it "should yield 'Class' for a PHostClassType" do
-      t = Puppet::Pops::Types::PHostClassType::DEFAULT
-      expect(calculator.string(t)).to eq('Class')
-    end
-
-    it "should yield 'Class[x]' for a PHostClassType[x]" do
-      t = Puppet::Pops::Types::PHostClassType.new('x')
-      expect(calculator.string(t)).to eq('Class[x]')
-    end
-
-    it "should yield 'Resource' for a PResourceType" do
-      t = Puppet::Pops::Types::PResourceType::DEFAULT
-      expect(calculator.string(t)).to eq('Resource')
-    end
-
-    it 'should yield \'File\' for a PResourceType[\'File\']' do
-      t = Puppet::Pops::Types::PResourceType.new('File')
-      expect(calculator.string(t)).to eq('File')
-    end
-
-    it "should yield 'File['/tmp/foo']' for a PResourceType['File', '/tmp/foo']" do
-      t = Puppet::Pops::Types::PResourceType.new('File', '/tmp/foo')
-      expect(calculator.string(t)).to eq("File['/tmp/foo']")
-    end
-
-    it "should yield 'Enum[s,...]' for a PEnumType[s,...]" do
-      t = enum_t('a', 'b', 'c')
-      expect(calculator.string(t)).to eq("Enum['a', 'b', 'c']")
-    end
-
-    it "should yield 'Pattern[/pat/,...]' for a PPatternType['pat',...]" do
-      t = pattern_t('a')
-      t2 = pattern_t('a', 'b', 'c')
-      expect(calculator.string(t)).to eq('Pattern[/a/]')
-      expect(calculator.string(t2)).to eq('Pattern[/a/, /b/, /c/]')
-    end
-
-    it "should escape special characters in the string for a PPatternType['pat',...]" do
-      t = pattern_t('a/b')
-      expect(calculator.string(t)).to eq("Pattern[/a\\/b/]")
-    end
-
-    it "should yield 'Variant[t1,t2,...]' for a PVariantType[t1, t2,...]" do
-      t1 = string_t
-      t2 = integer_t
-      t3 = pattern_t('a')
-      t = variant_t(t1, t2, t3)
-      expect(calculator.string(t)).to eq('Variant[String, Integer, Pattern[/a/]]')
-    end
-
-    it "should yield 'Callable' for generic callable" do
-      expect(calculator.string(all_callables_t)).to eql('Callable')
-    end
-
-    it "should yield 'Callable[0,0]' for callable without params" do
-      expect(calculator.string(callable_t)).to eql('Callable[0, 0]')
-    end
-
-    it "should yield 'Callable[t,t]' for callable with typed parameters" do
-      expect(calculator.string(callable_t(String, Integer))).to eql('Callable[String, Integer]')
-    end
-
-    it "should yield 'Callable[t,min,max]' for callable with size constraint (infinite max)" do
-      expect(calculator.string(callable_t(String, 0))).to eql('Callable[String, 0, default]')
-    end
-
-    it "should yield 'Callable[t,min,max]' for callable with size constraint (capped max)" do
-      expect(calculator.string(callable_t(String, 0, 3))).to eql('Callable[String, 0, 3]')
-    end
-
-    it "should yield 'Callable[min,max]' callable with size > 0" do
-      expect(calculator.string(callable_t(0, 0))).to eql('Callable[0, 0]')
-      expect(calculator.string(callable_t(0, 1))).to eql('Callable[0, 1]')
-      expect(calculator.string(callable_t(0, :default))).to eql('Callable[0, default]')
-    end
-
-    it "should yield 'Callable[Callable]' for callable with block" do
-      expect(calculator.string(callable_t(all_callables_t))).to eql('Callable[0, 0, Callable]')
-      expect(calculator.string(callable_t(string_t, all_callables_t))).to eql('Callable[String, Callable]')
-      expect(calculator.string(callable_t(string_t, 1,1, all_callables_t))).to eql('Callable[String, 1, 1, Callable]')
-    end
-
-    it 'should yield Unit for a Unit type' do
-      expect(calculator.string(unit_t)).to eql('Unit')
-    end
-
-    it "should yield 'NotUndef' for a PNotUndefType" do
-      t = not_undef_t
-      expect(calculator.string(t)).to eq('NotUndef')
-    end
-
-    it "should yield 'NotUndef[T]' for a PNotUndefType[T]" do
-      t = not_undef_t(data_t)
-      expect(calculator.string(t)).to eq('NotUndef[Data]')
-    end
-
-    it "should yield 'NotUndef['string']' for a PNotUndefType['string']" do
-      t = not_undef_t('hey')
-      expect(calculator.string(t)).to eq("NotUndef['hey']")
-    end
-  end
-
   context 'when processing meta type' do
     it 'should infer PType as the type of all other types' do
       ptype = Puppet::Pops::Types::PType
@@ -1880,6 +1780,7 @@ describe 'The type calculator' do
       expect(calculator.infer(Puppet::Pops::Types::PCollectionType::DEFAULT).is_a?(ptype)).to eq(true)
       expect(calculator.infer(Puppet::Pops::Types::PArrayType::DEFAULT     ).is_a?(ptype)).to eq(true)
       expect(calculator.infer(Puppet::Pops::Types::PHashType::DEFAULT      ).is_a?(ptype)).to eq(true)
+      expect(calculator.infer(Puppet::Pops::Types::PIterableType::DEFAULT  ).is_a?(ptype)).to eq(true)
       expect(calculator.infer(Puppet::Pops::Types::PRuntimeType::DEFAULT   ).is_a?(ptype)).to eq(true)
       expect(calculator.infer(Puppet::Pops::Types::PHostClassType::DEFAULT ).is_a?(ptype)).to eq(true)
       expect(calculator.infer(Puppet::Pops::Types::PResourceType::DEFAULT  ).is_a?(ptype)).to eq(true)
@@ -1892,38 +1793,39 @@ describe 'The type calculator' do
     end
 
     it 'should infer PType as the type of all other types' do
-      expect(calculator.string(calculator.infer(Puppet::Pops::Types::PUndefType::DEFAULT     ))).to eq('Type[Undef]')
-      expect(calculator.string(calculator.infer(Puppet::Pops::Types::PDataType::DEFAULT      ))).to eq('Type[Data]')
-      expect(calculator.string(calculator.infer(Puppet::Pops::Types::PScalarType::DEFAULT    ))).to eq('Type[Scalar]')
-      expect(calculator.string(calculator.infer(Puppet::Pops::Types::PStringType::DEFAULT    ))).to eq('Type[String]')
-      expect(calculator.string(calculator.infer(Puppet::Pops::Types::PNumericType::DEFAULT   ))).to eq('Type[Numeric]')
-      expect(calculator.string(calculator.infer(Puppet::Pops::Types::PIntegerType::DEFAULT   ))).to eq('Type[Integer]')
-      expect(calculator.string(calculator.infer(Puppet::Pops::Types::PFloatType::DEFAULT     ))).to eq('Type[Float]')
-      expect(calculator.string(calculator.infer(Puppet::Pops::Types::PRegexpType::DEFAULT    ))).to eq('Type[Regexp]')
-      expect(calculator.string(calculator.infer(Puppet::Pops::Types::PBooleanType::DEFAULT   ))).to eq('Type[Boolean]')
-      expect(calculator.string(calculator.infer(Puppet::Pops::Types::PCollectionType::DEFAULT))).to eq('Type[Collection]')
-      expect(calculator.string(calculator.infer(Puppet::Pops::Types::PArrayType::DEFAULT     ))).to eq('Type[Array[?]]')
-      expect(calculator.string(calculator.infer(Puppet::Pops::Types::PHashType::DEFAULT      ))).to eq('Type[Hash[?, ?]]')
-      expect(calculator.string(calculator.infer(Puppet::Pops::Types::PRuntimeType::DEFAULT   ))).to eq('Type[Runtime[?, ?]]')
-      expect(calculator.string(calculator.infer(Puppet::Pops::Types::PHostClassType::DEFAULT ))).to eq('Type[Class]')
-      expect(calculator.string(calculator.infer(Puppet::Pops::Types::PResourceType::DEFAULT  ))).to eq('Type[Resource]')
-      expect(calculator.string(calculator.infer(Puppet::Pops::Types::PEnumType::DEFAULT      ))).to eq('Type[Enum]')
-      expect(calculator.string(calculator.infer(Puppet::Pops::Types::PVariantType::DEFAULT   ))).to eq('Type[Variant]')
-      expect(calculator.string(calculator.infer(Puppet::Pops::Types::PPatternType::DEFAULT   ))).to eq('Type[Pattern]')
-      expect(calculator.string(calculator.infer(Puppet::Pops::Types::PTupleType::DEFAULT     ))).to eq('Type[Tuple]')
-      expect(calculator.string(calculator.infer(Puppet::Pops::Types::POptionalType::DEFAULT  ))).to eq('Type[Optional]')
-      expect(calculator.string(calculator.infer(Puppet::Pops::Types::PCallableType::DEFAULT  ))).to eq('Type[Callable]')
+      expect(calculator.infer(Puppet::Pops::Types::PUndefType::DEFAULT     ).to_s).to eq('Type[Undef]')
+      expect(calculator.infer(Puppet::Pops::Types::PDataType::DEFAULT      ).to_s).to eq('Type[Data]')
+      expect(calculator.infer(Puppet::Pops::Types::PScalarType::DEFAULT    ).to_s).to eq('Type[Scalar]')
+      expect(calculator.infer(Puppet::Pops::Types::PStringType::DEFAULT    ).to_s).to eq('Type[String]')
+      expect(calculator.infer(Puppet::Pops::Types::PNumericType::DEFAULT   ).to_s).to eq('Type[Numeric]')
+      expect(calculator.infer(Puppet::Pops::Types::PIntegerType::DEFAULT   ).to_s).to eq('Type[Integer]')
+      expect(calculator.infer(Puppet::Pops::Types::PFloatType::DEFAULT     ).to_s).to eq('Type[Float]')
+      expect(calculator.infer(Puppet::Pops::Types::PRegexpType::DEFAULT    ).to_s).to eq('Type[Regexp]')
+      expect(calculator.infer(Puppet::Pops::Types::PBooleanType::DEFAULT   ).to_s).to eq('Type[Boolean]')
+      expect(calculator.infer(Puppet::Pops::Types::PCollectionType::DEFAULT).to_s).to eq('Type[Collection]')
+      expect(calculator.infer(Puppet::Pops::Types::PArrayType::DEFAULT     ).to_s).to eq('Type[Array[?]]')
+      expect(calculator.infer(Puppet::Pops::Types::PHashType::DEFAULT      ).to_s).to eq('Type[Hash[?, ?]]')
+      expect(calculator.infer(Puppet::Pops::Types::PIterableType::DEFAULT  ).to_s).to eq('Type[Iterable]')
+      expect(calculator.infer(Puppet::Pops::Types::PRuntimeType::DEFAULT   ).to_s).to eq('Type[Runtime[?, ?]]')
+      expect(calculator.infer(Puppet::Pops::Types::PHostClassType::DEFAULT ).to_s).to eq('Type[Class]')
+      expect(calculator.infer(Puppet::Pops::Types::PResourceType::DEFAULT  ).to_s).to eq('Type[Resource]')
+      expect(calculator.infer(Puppet::Pops::Types::PEnumType::DEFAULT      ).to_s).to eq('Type[Enum]')
+      expect(calculator.infer(Puppet::Pops::Types::PVariantType::DEFAULT   ).to_s).to eq('Type[Variant]')
+      expect(calculator.infer(Puppet::Pops::Types::PPatternType::DEFAULT   ).to_s).to eq('Type[Pattern]')
+      expect(calculator.infer(Puppet::Pops::Types::PTupleType::DEFAULT     ).to_s).to eq('Type[Tuple]')
+      expect(calculator.infer(Puppet::Pops::Types::POptionalType::DEFAULT  ).to_s).to eq('Type[Optional]')
+      expect(calculator.infer(Puppet::Pops::Types::PCallableType::DEFAULT  ).to_s).to eq('Type[Callable]')
 
       expect(calculator.infer(Puppet::Pops::Types::PResourceType.new('foo::fee::fum')).to_s).to eq('Type[Foo::Fee::Fum]')
-      expect(calculator.string(calculator.infer(Puppet::Pops::Types::PResourceType.new('foo::fee::fum')))).to eq('Type[Foo::Fee::Fum]')
+      expect(calculator.infer(Puppet::Pops::Types::PResourceType.new('foo::fee::fum')).to_s).to eq('Type[Foo::Fee::Fum]')
       expect(calculator.infer(Puppet::Pops::Types::PResourceType.new('Foo::Fee::Fum')).to_s).to eq('Type[Foo::Fee::Fum]')
     end
 
     it "computes the common type of PType's type parameter" do
       int_t    = Puppet::Pops::Types::PIntegerType::DEFAULT
       string_t = Puppet::Pops::Types::PStringType::DEFAULT
-      expect(calculator.string(calculator.infer([int_t]))).to eq('Array[Type[Integer], 1, 1]')
-      expect(calculator.string(calculator.infer([int_t, string_t]))).to eq('Array[Type[Scalar], 2, 2]')
+      expect(calculator.infer([int_t]).to_s).to eq('Array[Type[Integer], 1, 1]')
+      expect(calculator.infer([int_t, string_t]).to_s).to eq('Array[Type[Scalar], 2, 2]')
     end
 
     it 'should infer PType as the type of ruby classes' do
@@ -1962,23 +1864,23 @@ describe 'The type calculator' do
     end
   end
 
-  context 'when asking for an enumerable ' do
-    it 'should produce an enumerable for an Integer range that is not infinite' do
+  context 'when asking for an iterable ' do
+    it 'should produce an iterable for an Integer range that is finite' do
       t = Puppet::Pops::Types::PIntegerType.new(1, 10)
-      expect(calculator.enumerable(t).respond_to?(:each)).to eq(true)
+      expect(calculator.iterable(t).respond_to?(:each)).to eq(true)
     end
 
-    it 'should not produce an enumerable for an Integer range that has an infinite side' do
+    it 'should not produce an iterable for an Integer range that has an infinite side' do
       t = Puppet::Pops::Types::PIntegerType.new(nil, 10)
-      expect(calculator.enumerable(t)).to eq(nil)
+      expect(calculator.iterable(t)).to eq(nil)
 
       t = Puppet::Pops::Types::PIntegerType.new(1, nil)
-      expect(calculator.enumerable(t)).to eq(nil)
+      expect(calculator.iterable(t)).to eq(nil)
     end
 
-    it 'all but Integer range are not enumerable' do
+    it 'all but Integer range are not iterable' do
       [Object, Numeric, Float, String, Regexp, Array, Hash].each do |t|
-        expect(calculator.enumerable(calculator.type(t))).to eq(nil)
+        expect(calculator.iterable(calculator.type(t))).to eq(nil)
       end
     end
   end
@@ -2012,16 +1914,16 @@ describe 'The type calculator' do
 
     it 'ensures that Struct key types are not generalized' do
       generic = struct_t({'a' => object_t}).generalize
-      expect(calculator.string(generic)).to eq("Struct[{'a'=>Any}]")
+      expect(generic.to_s).to eq("Struct[{'a' => Any}]")
       generic = struct_t({not_undef_t('a') => object_t}).generalize
-      expect(calculator.string(generic)).to eq("Struct[{NotUndef['a']=>Any}]")
+      expect(generic.to_s).to eq("Struct[{NotUndef['a'] => Any}]")
       generic = struct_t({optional_t('a') => string_t}).generalize
-      expect(calculator.string(generic)).to eq("Struct[{Optional['a']=>String}]")
+      expect(generic.to_s).to eq("Struct[{Optional['a'] => String}]")
     end
 
     it 'ensures that Struct value types are generalized' do
       generic = struct_t({'a' => range_t(1, 3)}).generalize
-      expect(calculator.string(generic)).to eq("Struct[{'a'=>Integer}]")
+      expect(generic.to_s).to eq("Struct[{'a' => Integer}]")
     end
 
     it "does not reduce by combining types when using infer_set" do