I wouldn't do it your intended way but do

my $start_with = another_value()
      or return mywarn("Could not get another value");
[download]

sub mywarn {
    warn $_ for @_;
    return;
};
[download]

but if you're hell-bent on confusing people with your program flow, see Scope::Upper and/or Continuation::Escape, which allow you to "skip" levels as you return up the call chain.

You know, that just pointed out the obvious to me. If I had this working properly.. It's not really perl anymore, is it.

We can look at somebody else's code, a subroutine, and we can have a good idea of where something returns. It seems the only safe way to do this would be to very explicitly name the function, something like warn_and_return_undef()- which kinda would beat the purpose of brevity- much better to actually warn and return undef.

I think this is what Fred P Brooks in the mythical man month (?) talks about in relation to sharpening tools that sharpen tools. A vicious programmer vice.

my $start_with = another_value()
      or ( warn("Could not get another value"), return );
[download]

my $start_with = another_value()
      or ( warn("Could not get another value"),
          return );
[download]

I don't find that very readable. It makes me wonder whether the parens are a list, or whether they are just there for precedence. And it makes me wonder if perl couldn't evaluate the return before the warn.

I would write it as:

my $start_with = another_value or do {
    warn "Could not get another value";
    return;
};
[download]

Alternatively,

do {
    warn "Could not get another value";
    return;
} unless my $start_with = another_value;
[download]

but that focusses on the exception, not on the action, so I'll be far less likely to write it that way.

wow! I can't imagine why you're so afraid of using ",". You need to use it for just about every function call!

Thank you, this is useful!

Two questions.. One on topic and one off topic.

1. You say..

   my $start_with = another_value()
      or ( warn("Could not get another value"), return );
   [download]

   Why not..

   my $start_with = another_value()
      or warn("Could not get another value"), return;
   [download]

   Or even

   my $start_with = another_value()
      or warn "Could not get another value", return;
   [download]

   I tried these out and they seem to work fine. I suppose it's maybe trying to mess with the compiler/interpreter being vague with arguments to warn(), in the last example.

   Are you using parenthesis as good practice/legibility only?

2. It seems that unless I want to create my own perl distro, there's no way to do as JavaFan suggests ( 779943 ).

   Perl's pretty freaking liberal with what it lets you do with symbol tables, but.. we can't just add another function to the language at compile time.

   I wonder if this is something lisp could do- probably not- this must be on the language design (compiler/interpreter) level, not the coding level (?).
   ( Actually, as Corion noted initially.. 779928 )

Why not..

I didn't check the relative precedence of "or" and ",". I also liked the visual grouping.

Or even

No, it doesn't work. It returns before evaluating warn.

It seems that unless I want to create my own perl distro, there's no way to do as JavaFan suggests

What JavaFan suggested works as is. If you mean to make it pretty... The best way probably would require language-level support.

we can't just add another function to the language at compile time

I guess it depends on what you mean by function. Out of context, I'd say that's not true.

sub resolve_value {
   my $start_with = another_value();
   unless $start_with {
        warn "Could not get another value";
        return;
   }
   my $continuation = shift;
   return $continuation->($start_with, @_);
}

# and here's how you use that code:

sub foo {
    # do some work here
    resolve_value(sub {
       my $start_with = shift;
       
       # do the rest of the work here
    })
}
[download]

If you care about performance you could also tail-call into the sub:

goto &resolve_value(sub {
    ...
});
[download]

I think you've been spending too much time in Rakudo moritz ;)

unless $start_with { ... } # missing "()" around $start_with
[download]

---

Smoothie, smoothie, hundre prosent naturlig!

my $start_with = another_value() or do {
    @_ = ("Could not get another value");
    goto &wreturn;
};
sub wreturn {warn @_}
[download]