The xor operator will do what you want:

$counter = $counter xor 1
[download]

or

$counter ^= 1
[download]

(tested with perl -wle "print $counter ^=1 for 1..3")

I agree that the XOR solution is perfectly correct, but why use that instead of NOT? Isn't

 $counter = ! $counter;

easier to read? That said, I have to admit that I like the snazzyness of the in place ^= syntax. It is hard to get more concise than that.

- doug

The difference is that $toggle ^= 1; leaves you with a number (0 or 1) while $toggle = !$toggle; leaves you with a boolean.

Honestly, it sounds like the OP wants a boolean, so the easier to read negation should be used. If he wants to display the boolean, that's an outputting formatting issue to be resolved then.

if ($toggle) {
    $toggle = 0;
} else {
    $toggle = 1;
}
[download]

can be written as

$toggle = $toggle ? 0 : 1;
[download]

And if you wanted a bitwise toggle, you could do

$toggle ^= 1;
[download]

But you asked for boolean, so you want the even simpler:

$toggle = !$toggle;
[download]

Of course if you want obscure you can use $|--. Consider:

print $|-- for 1 .. 4;
[download]

Prints:

1010
[download]

Although I wouldn't recommend it in a context where you wish to win friends and influence people among the bossing classes.

Just to make "lookup-tables" prettier. ;-)

$counter = [ 1 => 0 ] -> [ 1 <= $counter ];
[download]

ug, you create two variables every time you toggle it (one of which is an array!), and you rely on the undocumented values of <= returns. And the latter doesn't help make it prettier at all!

Or if you're not interested in the numeric value 0, but rather that it's a false value, you can also use this update step:

$counter = !$counter;
[download]

Or if you do want the numerical value:

$counter = !$counter || 0;
[download]

$toggle = 1 - $toggle;
[download]

Two more approaches:

- Using hashes:

  my %Next = ( 0 => 1, 1 => 0);
  my $Counter = 0;
  #...
  $Counter = $Next{$Counter};
[download]

- Decreasing instead of increasing:

  $Counter = abs --$Counter;
[download]

$Counter = - --$Counter;

Don't modify a variable that you're using elsewhere in an expression. At best, it's unclear. At worse, the result is undefined.

$toggle = - --$toggle;
[download]

should be

$toggle = -( $toggle - 1 );
[download]

which can be shortened to previously mentioned

$toggle = 1 - $toggle;
[download]

The behaviour of that is actually not defined. You may end up with $Counter being -1, or with purple daemons coming out of your USB port, ready to chew off your fingers.

$counter = int cos $counter * atan2(1, 0);
[download]

I cannot resist. You can also use a closure, every time you call it you get 0 or 1 alternatingly. You can create as many independent toggles as you want.

use strict;
use warnings;

sub create_toggle {
    my $flag = 0;
    return sub { $flag = 1-$flag } # your favorite method here
}

my $toggle = create_toggle;

print $toggle->()."\n" for 1..10;
[download]

UPDATE: ...or like this

use strict;
use warnings;
{
    package Toggler;
    sub new {
    my $flag =  0;
    return sub { $flag = 1-$flag }
    }
}

my $toggle = new Toggler;

print $toggle->()."\n" for 1..10;
[download]

I tend to use $toggle *= -1;

Update: I stand corrected, thanks LanX. I often use that for alternating rows but it's wrong here.

well it's a toggle but can't be used as boolean as the OP wanted , since 0*-1=0

Cheers Rolf

Your idea works the following way - even if it doesn't look as elegant any more:

$toggle = -1 * ($toggle - 0.5) + 0.5;
[download]

Rata (loving this thread)