List::MoreUtils offers a similar functionality:

use strict;
use warnings;
use List::MoreUtils qw/natatime/;

my @array = qw(a b c e 1 2 3 4 5 3 f);

my $it = natatime 3, @array;
while ( my @vals = $it->() ) {
    print "@vals\n";
}
[download]

Output:

a b c
e 1 2
3 4 5
3 f
[download]

BTW - I use this for generating multi-line output...

Here's another option for multi-line output (generated from a single line):

use strict;
use warnings;
use Text::Wrap;

$Text::Wrap::columns = 18;

my $text = <<END;
BTW - I use this for generating multi-line output - tables and such.
END

print wrap("  ", '', $text);
[download]

Output:

  BTW - I use
this for
generating
multi-line output
- tables and
such.
[download]

Hope this is helpful.

Using a subroutine that takes a code block as its first argument and applies that code to groups of size specified in the second argument taken from the remaining arguments.

use strict;
use warnings;

use Data::Dumper;

sub groupsOf (&$@);

my $doubleStack = [
   groupsOf
      { [ @_ ] }
      3,
      qw{ a b c e 1 2 3 4 5 3 f }
   ];

print Data::Dumper
   ->Dumpxs( [ $doubleStack ], [ qw{ doubleStack } ] );

sub groupsOf (&$@)
{
    my $rcToRun  = shift;
    my $groupsOf = shift;

    my $rcDoIt;
    $rcDoIt = sub
       {
           $rcToRun->(
              map shift, 1 .. ( @_ < $groupsOf ? @_ : $groupsOf )
              ),
           @_ ? &$rcDoIt : ();
       };

    &$rcDoIt;
}
[download]

The output.

$doubleStack = [
                 [
                   'a',
                   'b',
                   'c'
                 ],
                 [
                   'e',
                   '1',
                   '2'
                 ],
                 [
                   '3',
                   '4',
                   '5'
                 ],
                 [
                   '3',
                   'f'
                 ]
               ];
[download]

I hope this is of interest.

This works but it is not cool...

use strict;
use warnings;
use Data::Dumper;

my @array = qw(a b c e 1 2 3 4 5 3 f);
my $len = 3;
my @stack = map{$_%$len?():[grep{$_}@array[$_..$_+$len-1]]} 0..@array-
+1;
print Dumper \@stack;
[download]

...or this...a destructive version...

the

grep{$_} .......
[download]

also removes "" and 0 from the list. Should probably be

grep{defined $_} .....
[download]

Also - why use

@array -1
[download]

when you could use

$#array
[download]

I like the approach.... Perhaps

map{[
   grep {defined}
   @array[$_*$len..$_*$len+$len-1]
   ]} 0..$#array/$len
[download]

Is a little cleaner?

G'day spandox,

Not recommended for production code. :-)

#!/usr/bin/env perl

use strict;
use warnings;

use Data::Dump;

my @a = qw{a b c e 1 2 3 4 5 3 f};
my $x = 3;

dd [(map{@;==$x?do{$;=[@;];@;=($_);$;}:do{push(@;,$_);()}}@a),[@;]];
[download]

Output:

[["a", "b", "c"], ["e", 1, 2], [3, 4, 5], [3, "f"]]
[download]

[P.S. With "my @a = ();", the output is "[[]]".]

  DB<119> @a=a..e
 => ("a", "b", "c", "d", "e")

  DB<120> map [splice @a,0,3], 0..$#a/3
 => (["a", "b", "c"], ["d", "e"])
[download]

but beware of the case @a=()

> Anyone have a cool way to do this?

not really :(

I like this because it is small - HOWEVER it is destructive of the original array. It does often work for me though. in my code it looks like

my @array = qw(0 a b c e 1 2 3 4 5 3 f w);
my $len = 4;
print oxTable->new([ 
   map [splice @array,0,$len], 0..$#array/$len 
    ]);
[download]

Produces

+--+--+--+--+
|0 |a |b |c |
|e |1 |2 |3 |
|4 |5 |3 |f |
|w |  |  |  |
+--+--+--+--+
[download]

> I like this because it is small

I don't like it, IMHO it's

1. hard to read golfing!
2. not DRY
3. and furthermore buggy in edge cases.

you might get used to it, but the next one to maintain your code wont be "pleased".

> It does often work for me though.

Look! If you need it often, so why don't you just use your custom routine?

Just compare the overhead to document this hack with just encapsulating all the infos in a sub!

Or use something from List::MoreUtils ?

  DB<117> use List::MoreUtils qw/part/;

  DB<118> my $i; part {$i++ %3} a..h
 => (["a", "d", "g"], ["b", "e", "h"], ["c", "f"])

  DB<119> use feature 'state'; part {state $i++ %3} a..h
 => (["a", "d", "g"], ["b", "e", "h"], ["c", "f"])
[download]

update

oops sorry, this transposed the matrix, corrected code:

  DB<139> use feature "state";  part {state $i++/3} a..h
 => (["a", "b", "c"], ["d", "e", "f"], ["g", "h"])
[download]

Cheers Rolf

( addicted to the Perl Programming Language)

spandox:

The best I came up with is:

my @t = (qw( a b c e 1 2 3 4 5 3 f ));
my $len = 3;

my @u = map {[ @t[$_ .. $_+$len-1] ]} grep {!($_%$len)} 0 .. $#t;
[download]

Fairly clear, but there's really no point in not using a well-named subroutine.

...roboticus

When your only tool is a hammer, all problems look like your thumb.

Just for fun

Cheers,
R.