if (not $gas_cost < 1) {
    stuff here
}
continue here
[download]

($q=q:Sq=~/;[c](.)(.)/;chr(-||-|5+lengthSq)`"S|oS2"`map{chr |+ord
}map{substrSq`S_+|`|}3E|-|`7**2-3:)=~y+S|`+$1,++print+eval$q,q,a,
[download]

I'm curious. Every post has suggested either if (not $gas_cost < 1) or if ($gas_cost >= 1). Am I the only one who immediately thought unless ($gas_cost < 1)?

Do I just think strangely, or is unless too unclear for most people to consider using? (or is there some other reason for not using it?)

The OP seemed as a beginner question to me. I tried not to introduce unnecessary details. On the other hand, I usually use unless in post-position only, to prevent an else from creeping in.

($q=q:Sq=~/;[c](.)(.)/;chr(-||-|5+lengthSq)`"S|oS2"`map{chr |+ord
}map{substrSq`S_+|`|}3E|-|`7**2-3:)=~y+S|`+$1,++print+eval$q,q,a,
[download]

I find that unless() has a very small useful footprint. Sure, may be OK when there is a single condition:

unless ($things_went_wrong) { # do some stuff }
[download]

But, when there are multiple conditions, it gets tougher to keep straight:

unless ($result < $HIGHEST_VALUE && ! $bad_results{$result}) { # stuff
+ }
[download]

And then there is this legal, but almost much harder to follow, control structure:

unless ($result) {
    ## Do some stuff
}
elsif (!$result) {
    ## Do some other stuff
}
else {
    ## yet other stuff... 
}
[download]

In the end, 'unless(') is just a way to type 'if (!)', but with more keystrokes and it has a better chance of making your brain hurt. And, you never have to worry about decoding double negatives, or re-writing them if your control statements need to grow down the line if you just use 'if (!)'.

weak reasons :)

Perl::Critic::Policy::ControlStructures::ProhibitUnlessBlocks - Write if(! $condition) instead of unless($condition).

Perl::Critic::Policy::ControlStructures::ProhibitNegativeExpressionsInUnlessAndUntilConditions - Don't use operators like not, !~, and le within until and unless.

curious? Untillian Headache or about the semantic of until

L*

There are no rules, there are no thumbs..
Reinvent the wheel, then learn The Wheel; may be one day you reinvent one of THE WHEELS.

Probably neither, but refactoring code depends a great deal on the context and you haven't given us enough to play with. Personally I make frequent use of early exit and often use exceptions to handle error recovery. Early exits tend to reduce nesting blocks and exceptions take care of "jumping out of code" on errors. Maybe something like:

for my $gas_cost (@gasCosts) {
  if ($gas_cost < 1) {
    print "Bad gas - $gas_cost\n";
    next;
  }

  ...
}
[download]

or:

eval {
  die "Bad gas - $gas_cost\n" if $gas_cost < 1;
  ...
  return 1;
} or do {
  my $err = $@;
  
  print "Error handling gas: $err"
};
[download]

Long story short: old languages didn't have good Loop Control or early return, so they needed goto. Perl has them, so you are probably doing something bad if you need to use it. So consider how you can refactor to avoid it. This is coming from a Fortran hacker, so this warning should not be taken lightly.

To do what you have asked, the code is:

#!/usr/bin/perl
use strict;
use warnings;
use 5.012;
my $gas_cost = 1.5;
if ($gas_cost < 1) {goto ENDING_BRACE };
say "Intermediate";
ENDING_BRACE:
say "After";
[download]

{
    last if $gas_cost < 1;
    stuff here
}
continue here
[download]

func();
continue here;

sub func {
    return if $gas_cost < 1;
    stuff here
}
[download]

if ($gas_cost >= 1) {
    stuff here
}
continue here
[download]

You may also find How does 'goto LABEL' search for its label? informative.

Like this?

if ($gas_cost >= 1) {
  ... # stuff here
} else {
  ... # continue here
}
[download]

More reading, but directly to the point: using if, elsif and else in Perl.

Here's the official docs: perlsyn. Specifically the Compound Statements section.

Both your code examples are not equivalent and I'm pretty sure the second doesn't even do what you think it should be doing: it does NOT jump to "continue here" if the condition $gas_cost < 1 holds.

Up to date 12.04.

Say what? Is that a version number of something or April 12^th? or December 4^th?

if ($gas_cost < 1) {goto ENDING_BRACE };
stuff here
ENDING_BRACE:
continue here
[download]

Well, I'd reverse that and check for $gas_cost >= 1 and stuff stuff here into that conditional block. No ugly goto needed, no label needed:

if ($gas_cost >= 1) {
    stuff here
}
continue
[download]

Probably stuff here can be tucked away into a subroutine. But...

Have tried variations and read myself into circles.

...it looks like you are coming from C and are trying to grasp the perl goto. Well, read it up.

Others have suggested working code you could use. I am offering an explanation.

In Perl, calling a subroutine is not like gosub label. What you wrote as sub ENDING_BRACE; is, in Perl, what's called a "forward declaration". It does not define the subroutine, it merely tells the Perl compiler that you intend to define a subroutine named "ENDING_BRACE". Your code has no definition for ENDING_BRACE.

A possible definition might be:

sub ENDING_BRACE
{
   # handle ending brace
}
[download]

But, in your code as written, If $gas_cost were less than 1, the code "handle ending brace" would be executed, then ENDING_BRACE would return control to where it was called, so then "stuff here" would be executed, which is not what you want.