($die_on_error ? \&CORE::die : \&CORE::warn)->($error);
[download]

In 5.10.1, though, I am getting

Undefined subroutine &CORE::warn called
[download]

In older versions of Perl, you can still define your own subroutines and reference them (they can even be anonymous):

($die_on_error ? sub { die shift } : sub { warn shift } )->($error);
[download]

I do not find it more readable than

die $error if $die_on_error;
warn $error;
[download]

Thanks! I forgot to specify perl version, it's updated now. It's good to know it works in later perls.

It doesn't work because die and warn are keywords rather than subs in your namespace. As choroba has noted, in more recent versions of Perl many keywords are also available as functions in the CORE package, but the CORE package can behave abnormally sometimes.

Carp usually gives more helpful line numbers than die/warn, and as a bonus, these are real functions:

use Carp;

($die_on_error ? \&croak : \&carp)->($error);
[download]

That said, I'm really quite liking this as an alternative:

package My::Module;

use warnings::register;

...;
warnings::warnif("The flooble has become discombobulated!");
...;
[download]

The awesome thing about it is that people using your module can enable this warning like this:

use warnings 'Your::Module';
[download]

And if they'd prefer the warning to be fatal:

use warnings FATAL => 'Your::Module';
[download]

... and everything works just like Perl's built-in warnings categories! Yay!

(Though I'll note that the Perl 5.8 implementation of custom warnings categories kinda sucked. It's been good since 5.10.0.)

Sorry, I might have missed something, but why would you need reference to die in the first place?

Can't you have simply something like this:

if ($error) {
    $die_on_error ? die : warn->($error);
}
[download]

If not in your case, you could define a "my_die" function:

sub my_die{die "I died\d"}
[download]

$my_die = sub {die};
[download]

The reason is that I want to put this into the or:

do_something() or ($die_on_error ? \&die : \&warn)->("error");
[download]

But you simply don't need that: you can just die or warn in the usual way within your ternary operator, as you can see in the following Perl one-liners:

$ perl -e '$die_on_err=shift; 0 or ($die_on_err? die "failed\n" : warn
+ "warning\n")' 1
failed

$ perl -e '$die_on_err=shift; 0 or ($die_on_err? die "failed\n" : warn
+ "warning\n")' 0
warning
[download]

sub report {
  if ($die_on_error) {
    die $_[0];
  } else {
    warn $_[0];
  }
}
...
report($error) if ($error);
[download]

I don't think you want to have to type all that nonsense every time you need to report an error.

$SIG{'__WARN__'} = sub { die @_ } if $die_on_error;
warn "foooooo";
[download]

Does not quite work if you allow your code to spit out warnings for other reasons. In that case, you have to tag your speacial warnings, e.g.:

$SIG{'__WARN__'} = sub { die @{$_[0]} if ref $_[0] eq 'ARRAY'; warn @_
+; } if $die_on_error;
warn "foooooo"; # never dies
warn ["foooooo"]; # sometimes dies
[download]