Parents (Total: 19)

The searched file hash is included in 19 parent files which include package known and seen by metalookup. A sample is included below:

Key	Value
MD5	CDD99A21530C4EC6FCCC0620CAEE2926
PackageArch	noarch
PackageDescription	The type system provided by Moose effectively makes all of its builtin type global, as are any types you declare with Moose. This means that every module that declares a type named 'PositiveInt' is sharing the same type object. This can be a problem when different parts of the code base want to use the same name for different things. This package lets you declare types using short names, but behind the scenes it namespaces all your type declarations, effectively prevent name clashes between packages. This is done by creating a type library module like 'MyApp::Types' and then importing types from that module into other modules. As a side effect, the declaration mechanism allows you to write type names as barewords (really function calls), which catches typos in names at compile time rather than run time. This module also provides some helper functions for using Moose types outside of attribute declarations. If you mix string-based names with types created by this module, it will warn, with a few exceptions. If you are declaring a 'class_type()' or 'role_type()' within your type library, or if you use a fully qualified name like '"MyApp::Foo"'.
PackageName	perl-MooseX-Types
PackageRelease	40.2
PackageVersion	0.50
SHA-1	063579BAAFA0452B3E0A5D74EB1A7B3175C3DC1D
SHA-256	CE84A6A1D6B66D6ACE256F684BE10512C09FE592A95A95539B3740F59EDE38C7

Key	Value
MD5	D636B8361FBF92850E721621238424D8
PackageArch	noarch
PackageDescription	The type system provided by Moose effectively makes all of its builtin type global, as are any types you declare with Moose. This means that every module that declares a type named 'PositiveInt' is sharing the same type object. This can be a problem when different parts of the code base want to use the same name for different things. This package lets you declare types using short names, but behind the scenes it namespaces all your type declarations, effectively prevent name clashes between packages. This is done by creating a type library module like 'MyApp::Types' and then importing types from that module into other modules. As a side effect, the declaration mechanism allows you to write type names as barewords (really function calls), which catches typos in names at compile time rather than run time. This module also provides some helper functions for using Moose types outside of attribute declarations. If you mix string-based names with types created by this module, it will warn, with a few exceptions. If you are declaring a 'class_type()' or 'role_type()' within your type library, or if you use a fully qualified name like '"MyApp::Foo"'.
PackageName	perl-MooseX-Types
PackageRelease	40.14
PackageVersion	0.50
SHA-1	07D26C913D5A1C20D4DD4BCB85075C0B424D70C9
SHA-256	84CB9592E8DDD0585E652E6FC9A18470918E2627C71D1D0FFB5A66D440895CDB

Key	Value
MD5	45097ED4DD5D9095160D1F712282A027
PackageArch	noarch
PackageDescription	The type system provided by Moose effectively makes all of its builtin type global, as are any types you declare with Moose. This means that every module that declares a type named 'PositiveInt' is sharing the same type object. This can be a problem when different parts of the code base want to use the same name for different things. This package lets you declare types using short names, but behind the scenes it namespaces all your type declarations, effectively prevent name clashes between packages. This is done by creating a type library module like 'MyApp::Types' and then importing types from that module into other modules. As a side effect, the declaration mechanism allows you to write type names as barewords (really function calls), which catches typos in names at compile time rather than run time. This module also provides some helper functions for using Moose types outside of attribute declarations. If you mix string-based names with types created by this module, it will warn, with a few exceptions. If you are declaring a 'class_type()' or 'role_type()' within your type library, or if you use a fully qualified name like '"MyApp::Foo"'.
PackageName	perl-MooseX-Types
PackageRelease	40.3
PackageVersion	0.50
SHA-1	07FF4D0C2775AA35C310BDF462FD8DCEFF9D942B
SHA-256	79DE88E0342609333CBC6E40428A2DF855F97F8D2EC73E9C403AF04BC44AB7A3

Key	Value
MD5	9CD7578B5EE294CC49EE8D45AAB5DF0D
PackageArch	noarch
PackageDescription	The type system provided by Moose effectively makes all of its builtin type global, as are any types you declare with Moose. This means that every module that declares a type named 'PositiveInt' is sharing the same type object. This can be a problem when different parts of the code base want to use the same name for different things. This package lets you declare types using short names, but behind the scenes it namespaces all your type declarations, effectively prevent name clashes between packages. This is done by creating a type library module like 'MyApp::Types' and then importing types from that module into other modules. As a side effect, the declaration mechanism allows you to write type names as barewords (really function calls), which catches typos in names at compile time rather than run time. This module also provides some helper functions for using Moose types outside of attribute declarations. If you mix string-based names with types created by this module, it will warn, with a few exceptions. If you are declaring a 'class_type()' or 'role_type()' within your type library, or if you use a fully qualified name like '"MyApp::Foo"'.
PackageName	perl-MooseX-Types
PackageRelease	lp152.40.1
PackageVersion	0.50
SHA-1	0867D8F6C1CDBEF1EDF36C0FE3D1726148750922
SHA-256	B497AB556EA6F5B212DA80AAE398732C36582AE79CEBB933AEFDAFEED6F9950B

Key	Value
MD5	AB4E48A4ED1B6AAC5C5C4A3EF545AF82
PackageArch	noarch
PackageDescription	The type system provided by Moose effectively makes all of its builtin type global, as are any types you declare with Moose. This means that every module that declares a type named 'PositiveInt' is sharing the same type object. This can be a problem when different parts of the code base want to use the same name for different things. This package lets you declare types using short names, but behind the scenes it namespaces all your type declarations, effectively prevent name clashes between packages. This is done by creating a type library module like 'MyApp::Types' and then importing types from that module into other modules. As a side effect, the declaration mechanism allows you to write type names as barewords (really function calls), which catches typos in names at compile time rather than run time. This module also provides some helper functions for using Moose types outside of attribute declarations. If you mix string-based names with types created by this module, it will warn, with a few exceptions. If you are declaring a 'class_type()' or 'role_type()' within your type library, or if you use a fully qualified name like '"MyApp::Foo"'.
PackageName	perl-MooseX-Types
PackageRelease	bp152.41.2
PackageVersion	0.50
SHA-1	0B453C59451307DCCA7E8CC9C344F21D07C81225
SHA-256	5A5E858D0AEACCB90F67D164E0E38D8EDAF15AF16392CE829698D36E7337CCF5

Key	Value
MD5	CBF1FF997C09CD173BCDC5D6A0AB1EB3
PackageArch	noarch
PackageDescription	The type system provided by Moose effectively makes all of its builtin type global, as are any types you declare with Moose. This means that every module that declares a type named 'PositiveInt' is sharing the same type object. This can be a problem when different parts of the code base want to use the same name for different things. This package lets you declare types using short names, but behind the scenes it namespaces all your type declarations, effectively prevent name clashes between packages. This is done by creating a type library module like 'MyApp::Types' and then importing types from that module into other modules. As a side effect, the declaration mechanism allows you to write type names as barewords (really function calls), which catches typos in names at compile time rather than run time. This module also provides some helper functions for using Moose types outside of attribute declarations. If you mix string-based names with types created by this module, it will warn, with a few exceptions. If you are declaring a 'class_type()' or 'role_type()' within your type library, or if you use a fully qualified name like '"MyApp::Foo"'.
PackageMaintainer	https://bugs.opensuse.org
PackageName	perl-MooseX-Types
PackageRelease	bp154.1.16
PackageVersion	0.50
SHA-1	1C1A3FAFCDE5262CE7F5D38CF5C1A001E3A8B93E
SHA-256	C9ED9144944FA340F83729D6E8668C46EE4AAD0A1850946801DFD5691918B6B4

Key	Value
MD5	DB4F8628C704FF95D9BEA7E5054C7879
PackageArch	noarch
PackageDescription	The type system provided by Moose effectively makes all of its builtin type global, as are any types you declare with Moose. This means that every module that declares a type named 'PositiveInt' is sharing the same type object. This can be a problem when different parts of the code base want to use the same name for different things. This package lets you declare types using short names, but behind the scenes it namespaces all your type declarations, effectively prevent name clashes between packages. This is done by creating a type library module like 'MyApp::Types' and then importing types from that module into other modules. As a side effect, the declaration mechanism allows you to write type names as barewords (really function calls), which catches typos in names at compile time rather than run time. This module also provides some helper functions for using Moose types outside of attribute declarations. If you mix string-based names with types created by this module, it will warn, with a few exceptions. If you are declaring a 'class_type()' or 'role_type()' within your type library, or if you use a fully qualified name like '"MyApp::Foo"'.
PackageName	perl-MooseX-Types
PackageRelease	lp150.40.2
PackageVersion	0.50
SHA-1	25096C59F823B9FA47958576C3BD1F39B2B467AF
SHA-256	BD7745B64C6487E045B2ED09246DECE028ED47676C563C252E135A97E2BE8269

Key	Value
MD5	61AA008FDD7B488BD11114F669D376AF
PackageArch	noarch
PackageDescription	The type system provided by Moose effectively makes all of its builtin type global, as are any types you declare with Moose. This means that every module that declares a type named 'PositiveInt' is sharing the same type object. This can be a problem when different parts of the code base want to use the same name for different things. This package lets you declare types using short names, but behind the scenes it namespaces all your type declarations, effectively prevent name clashes between packages. This is done by creating a type library module like 'MyApp::Types' and then importing types from that module into other modules. As a side effect, the declaration mechanism allows you to write type names as barewords (really function calls), which catches typos in names at compile time rather than run time. This module also provides some helper functions for using Moose types outside of attribute declarations. If you mix string-based names with types created by this module, it will warn, with a few exceptions. If you are declaring a 'class_type()' or 'role_type()' within your type library, or if you use a fully qualified name like '"MyApp::Foo"'.
PackageName	perl-MooseX-Types
PackageRelease	bp153.41.1
PackageVersion	0.50
SHA-1	2B9D9F973661FACFC72B1DB418F267D03A46BE80
SHA-256	2E2778068BCB965A4371DE6205B898EB191B087BB80D7680C9B7C47CEE703A27

Key	Value
MD5	F1346C1263204C76D91B3A2E9FE28822
PackageArch	noarch
PackageDescription	The type system provided by Moose effectively makes all of its builtin type global, as are any types you declare with Moose. This means that every module that declares a type named 'PositiveInt' is sharing the same type object. This can be a problem when different parts of the code base want to use the same name for different things. This package lets you declare types using short names, but behind the scenes it namespaces all your type declarations, effectively prevent name clashes between packages. This is done by creating a type library module like 'MyApp::Types' and then importing types from that module into other modules. As a side effect, the declaration mechanism allows you to write type names as barewords (really function calls), which catches typos in names at compile time rather than run time. This module also provides some helper functions for using Moose types outside of attribute declarations. If you mix string-based names with types created by this module, it will warn, with a few exceptions. If you are declaring a 'class_type()' or 'role_type()' within your type library, or if you use a fully qualified name like '"MyApp::Foo"'.
PackageMaintainer	https://bugs.opensuse.org
PackageName	perl-MooseX-Types
PackageRelease	bp156.3.1
PackageVersion	0.50
SHA-1	3B914CBE81E4636FD896A5E1F1167B79575A5757
SHA-256	A5164138CDA6F49763B0713E44644F694AF44F677E2859E0888C984763E7286E

Key	Value
MD5	779582C48EF4554346B690DEBF326B18
PackageArch	noarch
PackageDescription	The type system provided by Moose effectively makes all of its builtin type global, as are any types you declare with Moose. This means that every module that declares a type named 'PositiveInt' is sharing the same type object. This can be a problem when different parts of the code base want to use the same name for different things. This package lets you declare types using short names, but behind the scenes it namespaces all your type declarations, effectively prevent name clashes between packages. This is done by creating a type library module like 'MyApp::Types' and then importing types from that module into other modules. As a side effect, the declaration mechanism allows you to write type names as barewords (really function calls), which catches typos in names at compile time rather than run time. This module also provides some helper functions for using Moose types outside of attribute declarations. If you mix string-based names with types created by this module, it will warn, with a few exceptions. If you are declaring a 'class_type()' or 'role_type()' within your type library, or if you use a fully qualified name like '"MyApp::Foo"'.
PackageMaintainer	https://bugs.opensuse.org
PackageName	perl-MooseX-Types
PackageRelease	lp151.2.1
PackageVersion	0.50
SHA-1	3E549D2BE9DC26CAB27EAC56E01BEAA8C28A3A8C
SHA-256	E8DDA929104E67F76A13AB89F2DF3E0911AF9B942AC1CD98BD9CCBEEC4993BF5