Imagine instead I wrote "the risk and fragility of using fuzzy regular expression matches for exception handling, especially when type checks and polymorphism are much more reliable".

And I say you are talking bollocks.

• Because "type checks" are just string compares.

  Pretty much exactly:

  if( ref( $obj ) eq $type ) { ... 
  ## or
  if( $obj =~ m[=$type$] ) { ...
  [download]

  .
• And polymorphism--of the type you are alluding to--is just multiple string compares.

  Pretty much:

  if( ref( $exception ) eq $type )
  or grep{ ref( $exception ) eq $_ } @{ $type::ISA } ) {  ...
  ## or
  if( $exception =~ m[=$type$]
  or grep{ $exception =~ m[=$_] } @{ $type::ISA } ) {  ...
  [download]

which demonstrates the lie of "more reliable, never mind "much more reliable.

You are selling a philosophy--your own home-spun, personal prejudice--on the basis of a technical merit which it simply does not live up to.

Exception::Class exceptions are:

1. defined in terms of strings:

   use Exception::Class (
       'MyException',
   
       'AnotherException' => {
           isa => 'MyException'
       },
   [download]

2. thrown in terms of strings: MyExceptions->throw( error => 'Divisor undefined' ) unless defined $d;
3. and caught in terms of strings: if ( $e = Exception::Class->caught('MyException') ) {

Which means you're even more reliant upon string compares, but now you have more places to change in order to maintain them.

I really wonder if you think through your justifictions at all. It sure doesn't look like it.