Bug #132918 for Type-Tiny: Unable to use provided is_InstanceOf

It does certainly make sense. Also, say: is_ArrayRef( \@integers, Int ) However, the is_Foo functions have a ($) prototype, so allowing them to take a second parameter could break backcompat in some cases. As a side-note, you can do this: use Types::Standard is_InstanceOf => { of => 'Foo', -as => 'is_Foo', }; my $obj = bless {}, "Foo"; if ( is_Foo $obj ) { print "Found a foo!\n"; } Assuming you have Type::Tiny::XS installed, the is_Foo() function will be implemented in XS so REALLY fast. Faster than checking: if ( blessed($obj) && $obj->isa("Foo") ) { print "Found a foo!\n"; } Similar speed (I need to benchmark it more) to the new Perl 5.32 isa operator: if ( $obj isa Foo ) { print "Found a foo!\n"; }

Show quoted text
If @params has more than, say, 10 integers, then you'll probably find this to be faster: ArrayRef->of(Int)->check( \@params ) I've also been working lately on something like: Int->all( @params ) # => bool Int->any( @params ) # => bool my @ints = Int->grep( @params ) # => list of ints And: my $Rounded = Int->plus_coercions(Num, 'int($_)'); my @ints = $Rounded->map( @numbers ); I will think about adding is_InstanceOf($obj, $class) but more likely I'll just document that for some parameterized types, the is_* functions aren't very useful. is_InstanceOf = is_Object is_HasMethods = is_Object is_Enum = is_Str is_StrMatch = is_Str and so on.

I've now released isa.pm which is separate from Type::Tiny (but will hook into Type::Tiny::XS if it's available) that lets you do this: use isa 'MyObject'; my $obj = MyObject->new; if ( isa_MyObject $obj ) { ...; } It is way faster than a two-argument form of is_InstanceOf could ever be, and even twice the speed of the Perl 5.32 native isa operator.

I was pretty convinced that the is_ functions were prototyped ($) so allowing them to accept a second argument would break stuff. Turns out that the is_ functions don't have prototypes, so it shouldn't break anything that assumed a prototype of ($). It's very easy to implement. (About 4 new lines of code, and a change to one existing line.) However, it has one big drawback. Currently checks like is_ArrayRef, is_HashRef, etc can be done using an XS sub. To allow is_ArrayRef($foo, Int) to work, they'd need to be wrapped in a Perl sub, making them much slower. Before the change, is_Object(undef) and is_InstanceOf(undef) run at the same speed: [tai@titania pts/5 p5-type-tiny]$ perl bench.tmp Rate is_Object is_InstanceOf is_Object 24439618/s -- -2% is_InstanceOf 24922676/s 2% -- After the change, is_InstanceOf(undef) gets slowed right down! [tai@titania pts/5 p5-type-tiny]$ perl -Ilib bench.tmp Rate is_InstanceOf is_Object is_InstanceOf 4633858/s -- -81% is_Object 24439618/s 427% -- Slowing down is_InstanceOf isn't a huge issue really, because people still have a fast is_Object. But slowing down is_ArrayRef and is_HashRef are a big no from me.

Perhaps having a general "is()" function would be useful? use strict; use warnings; use feature 'say'; { my %cache; sub is { my $type = shift; my $caller = caller; my $check = ( $cache{$caller}{$type} ||= do { require Type::Utils; my $type_object = Type::Utils::dwim_type($type, for => $caller); if ( ! $type_object ) { require Carp; Carp::confess("Cannot find type $type; failed"); return !!0; } $type_object->compiled_check; } ); goto $check if @_==1; $check->($_) || return !!0 for @_; return !!1; } } say is( 'ArrayRef' => [] ); say is( 'InstanceOf[Bleh]' => bless({}, 'Bleh') );

https://metacpan.org/release/TOBYINK/Type-Tiny-1.011_002 use Types::Standard qw( ArrayRef Int ); use Type::Utils qw( is ); if ( is ArrayRef[Int], \@numbers ) { say "It's all integers!\n"; } Or even: use Types::Standard qw( Int ); if ( Int->all(@numbers) ) { say "It's all integers!\n"; }

Thank you so much, this is very helpful!