\( (sub{6..9})->() )
[download]

    \( &{sub{6..9}}() )
[download]

jdporter
The 6th Rule of Perl Club is -- There is no Rule #6.

\do{6..9}

-sauoq
"My two cents aren't worth a dime.";

Neat! From that I realised that you can also do

[\map$_,1..9]
[download]

But yours is much tidier.

---

Examine what is said, not who speaks.

The 7th Rule of perl club is -- pearl clubs are easily damaged. Use a diamond club instead.

Does too, you have to write \( &{sub{6..9}}() )

Makeshifts last the longest.

use Data::Dumper;

print Dumper [(3,4,5,6)];
print Dumper [(3  .. 6)];

print Dumper [\(3,4,5,6)];
print Dumper [\(3  .. 6)];
[download]

[\(3,4,5,6)] yields $VAR1 = [\3,\4,\5,\6];
[\(3  .. 6)] yields $VAR1 = [[3,4,5,6]];

jeffa

use Data::Dumper;

{
    $a = 1;
    $b = 2;
    $c = 3;
    @a = \($a,$b, $c);
    print @a, "\n";#this is an array of ref
}

{
    $a = 1;
    $b = 2;
    $c = 3;
    $d = [\($a,$b, $c)];
    print @$d, "\n";#this is an array of ref
}

{
    @a = \(1..3);
    print Dumper(@a);#this is an ref to an array
}
[download]

1. Good syntax should be consistant all the way
2. What I actually get matches what I see

Another example of bad syntax: the other day I tried redo within a do {} until block, but Perl complains that I could not use redo outside a loop block, which means Perl does not take do {} until as a loop block.

That is documented behaviour (see perlsyn), though I must agree not very consistent. It applies not only to do {} until but also to do {} while. perlsyn suggests a workaround like this

do {{
  next if /^#/;
  # do something
}} until /^\s*$/;
[download]

but you have to adjust this to be able to use last.

My suggestion is to not use those constructs altogether and instead emulate them with bare blocks and redo ...

# do {} while condition
{
  # some code
  redo if condition;
}

# do {} until condition
{
  # some code
  redo unless condition;
}
[download]

-- Hofmator

Argh. Please don't use naked blocks with redo as loops, it's a nightmare to read. When I see a naked block, I expect to be looking at a private lexical scope, not an unadorned loop. If you need next, wrap the inner part with a naked block:

do {{
    $bar;
    baz() or next;
}} while $foo;
[download]

If you need last, wrap the whole thing:

{ do {
    $bar;
    baz() and last;
} while $foo; }
[download]

Of course, if you need both, it does get awfully clumsy:

LOOP: { do {{
    $bar;
    baz() or next;
    quux() and last LOOP;
}} while $foo; }
[download]

In that case, and if you're so inclined then maybe in the other cases as well, I propose:

while(1) {
    $bar;
    baz() or next;
    quux() and last;
}
[download]

At least it documents the loop nature of the block, even if the break condition is again somewhat hidden.

Makeshifts last the longest.

I think the thing with the do {} syntax is that you aren't iterating with the do block.

You are iterating the do block itself.

For example:

$i=5; print do{ --$1 };              # prints 4
$i=5; print do{ --$i } while $i;     # prints 43210
[download]

However, this is directly analogous to

$i=5; print --$1;              # prints 4
$i=5; print --$i while $i;     # prints 43210
[download]

In the latter example, its very clear that the while modifier form is iterating the print.

The former example, the while modifier is iterating the print also. It just so happens that the print has a do block as one of its terms. This is made clearer if you use the brackets on the print function like this.

$i=5;
print( do{--$i;} ) while $i;
[download]

The confusion comes because we often format the construct like this

$i=5;
do {
     print --$i;
} while ($i);
[download]

Which makes it look like an iterate-at-least-once version of

$i = 5;
while ($i) {
     print --$i;
}
[download]

But you can show the difference by doing

my ($i, $j) = (5, 0);
$j += do {
    print --$i;
} while ($i);
print $j; # prints 5.
[download]

Where the value 5 comes from the accumulation of the five 'successful' (1) return codes from the print function.

Additionally

If there is an inconsistancy with do, it's that the way it operates as an rvalue, makes it look somewhat analogous to the sort, map & grep functions, in as much as I half expected

print do( 'fred' ); to work like print do{ 'fred' } Somewhat like

 print map $_, 'fred'; is similar to print map{ $_ } 'fred';.

Actually, the error message from

 print do( 'fred' ); confuses me completly.

---

Examine what is said, not who speaks.

The 7th Rule of perl club is -- pearl clubs are easily damaged. Use a diamond club instead.

Actually, the error message from print do( 'fred' ); confuses me completly.

What error message? You are aware of the different variants of do? From perldoc -f do

do BLOCK
  [...]

do SUBROUTINE(LIST)
  [...]

do EXPR
  Uses the value of EXPR as a filename and executes
  the contents of the file as a Perl script.
[download]

so probably the file named 'fred' doesn't exist and do returns simply undef - at least that's what it does here (on perl 5.6.0) generating thus a warning about Use of uninitialized value in print ...

-- Hofmator

In list context, it returns an list of values counting (up by ones) from the left value to the right value. If the left value is greater than the right value then it returns the empty array.

What is that "n" doing there? It seems "list" was once "array"... (update: the documentation for Perl 5.6 indeed says "array", I am quoting from the docs for 5.8) And shouldn't that last part be "the empty list"?

A couple of sentences later, it says:

In the current implementation, no temporary array is created when the range operator is used as the expression in foreach loops, but older versions of Perl might burn a lot of memory when you write something like this:

for (1 .. 1_000_000) {
    # code
}
[download]

This seems to suggest that when not used in for (foreach) a temporary array is created, which would explain a lot...

— Arien

This seems to suggest that when not used in for (foreach) a temporary array is created...

It's not clear. Certainly an array seems to be created in the case of \(5..9), because a reference to the array is returned. (This in itself is very odd.)
But in the case of @a = (5..9), there's no way to tell (without guts diving).
And the range operator is overloaded to have completely different semantics in scalar context,
so we can't even do the simple $n=(5..7); if ( $n == 3 ) test for an array.

jdporter
The 6th Rule of Perl Club is -- There is no Rule #6.