In the latest development releases of Types::Standard, you can do this:

use Types::Standard is_InstanceOf => { of => "FishTaco::Topping", -as 
+=> "is_Topping" };

is_Topping( $something );  # returns a boolean
[download]

If you've got Type::Tiny::XS installed, this will be an XS function, so pretty darn fast to call. I haven't done a lot of benchmarking on it, but I'd wager a lot faster than a blessed+isa check. If you don't, then it's still not going to be slow.

(Older versions, you can do something like this for the same effect...

BEGIN {
  require Types::Standard;
  *is_Topping = Types::Standard::InstanceOf->parameterize("FishTaco::T
+opping")->compiled_check;
};
[download]

Newer versions just provide support for of in the import method.)

Terrific. By manually I meant this more than isa/blessed–

    my $type = InstanceOf['FishTaco::Topping'];
      …
        if ( $type->($topping) ) …
[download]

$type->($value) is a live-or-die function rather than returning a boolean. It returns $value if it lives. Makes it easy to do something like:

sub set_name {
  my $self  = Object->( shift );
  my $value = Str->( shift );
  $self->{name} = $value;
}
sub get_name {
  my $self = Object->( shift );
  return $self->{name};
}
[download]

$type->check($value) returns a boolean.

Exporting an is_Topping (boolean) or assert_Topping (live or die) function will be faster because it will avoid overhead from things like overloading, method lookups, etc. Though what you've already got is unlikely to be a major bottleneck for your application, so I'd mostly say go with what you feel is more readable.

toby döt ink