sub chunks{ 
    my( $n, @in ) = @_; 
    join ",\n", map join(' ', splice @in, 0, $n), 0 .. $#in / $n;
};;

print chunks( 3, 'a'..'z' );;
a b c,
d e f,
g h i,
j k l,
m n o,
p q r,
s t u,
v w x,
y z

print chunks( 10, 'a'..'z' );;
a b c d e f g h i j,
k l m n o p q r s t,
u v w x y z

print chunks( 26, 'a'..'z' );;
a b c d e f g h i j k l m n o p q r s t u v w x y z

print chunks( 13, 'a'..'z' );;
a b c d e f g h i j k l m,
n o p q r s t u v w x y z

print chunks( 6, 'a'..'z' );;
a b c d e f,
g h i j k l,
m n o p q r,
s t u v w x,
y z
[download]

I agree that this isn't necessarily the best task to use recursion for, but here's one possibility:

use Data::Dumper;

sub mk_chunker
{
    my $n = shift;
    die unless $n > 0;
    my $sub;
    return $sub = sub {
        return \@_ if @_ < $n;
        return (
            [ @_[0..$n-1] ],
            $sub->(@_[$n..$#_]), # recursion
        );
    };
}

*chunk_5 = mk_chunker(5);

print Dumper chunk_5('a' .. 'z');
[download]

The closure in mk_chunker is a good candidate for Perl 5.16's new __SUB__ feature...

use 5.016;

sub mk_chunker
{
    my $n = shift;
    die unless $n > 0;
    return sub {
        return \@_ if @_ < $n;
        return (
            [ @_[0..$n-1] ],
            __SUB__->(@_[$n..$#_]), # recursion
        );
    };
}
[download]

Use array references:

#! perl
use strict;
use warnings;

my @list = ( 'a' .. 'z' );
my @array_chunk5 = _array_chunk5( @list );

print "Array chunk of 5 =\n";
my $count;
print "Chunk ", ++$count, ":\n", join("\n", @$_), "\n\n" for @array_ch
+unk5;

sub _array_chunk5
{
    my @arr = @_;

    if (@arr > 5)
    {
        my   @chunk;
        push(@chunk, shift @arr) for (1 .. 5);

        return ( \@chunk, _array_chunk5(@arr) );
    }
    else
    {
        return \@arr;
    }
}
[download]

HTH,

Another recursive solution using a subroutine that takes a block of code to execute against a "chunked" list.

use strict;
use warnings;

use 5.010;

sub groupsOf (&$@);

my @list = ( q{a} .. q{z} );

say for groupsOf { qq{@_,} } 5, @list;
say for groupsOf { qq{@_,} } 7, @list;

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

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

    &$rcDoIt;
}
[download]

I hope this is of interest.

Update: Oops, forgot to post the output :-(

a b c d e,
f g h i j,
k l m n o,
p q r s t,
u v w x y,
z,
a b c d e f g,
h i j k l m n,
o p q r s t u,
v w x y z,
[download]

Well, this isn't something you should use recursion for

#!/usr/bin/perl --
use strict; use warnings;
use Data::Dump;
use List::AllUtils qw' natatime ';
my @x = ('a' .. 'z');
my $it = natatime 5, @x;
my @yo;
while (my @vals = $it->())
{
    push @yo, "@vals,\n";
}
chomp $yo[-1];
chop  $yo[-1];
dd \@yo;
__END__
[
  "a b c d e,\n",
  "f g h i j,\n",
  "k l m n o,\n",
  "p q r s t,\n",
  "u v w x y,\n",
  "z",
]
[download]

this isn't something you should use recursion for

s/should/need to/

You also don’t need a module. Here is a solution using a stateful subroutine as an iterator:

#! perl
use strict;
use warnings;

my @list = ('a' .. 'z');
my $size = 5;

_array_chunk_it($size, @list);

while (my @chunk = _array_chunk_it())
{
    print "Array chunk of $size =\n", join("\n", @chunk), "\n\n";
}

{
    my ($array, $count);

    sub _array_chunk_it
    {
        my @chunk;

        if (@_)
        {
            $count = shift;
            $array = [ @_ ];
        }
        else
        {
            for (1 .. $count)
            {
                push(@chunk, shift @$array) if @$array;
            }
        }

        return @chunk;
    }
}
[download]

(With newer versions of Perl, this can be rewritten using state.)

TMTOWTDI :-)

Update: ++Anonymous Monk for the superior version using a closure, below.

Athanasius <°(((>< contra mundum

With older versions of Perl, it can be rewritten as a proper iterator :-)

use strict;
use warnings;

my @list = ('a' .. 'z');
my $size = 5;

my $chunker = _array_chunk_it($size, @list);

while (my @chunk = $chunker->())
{
  print "Array chunk of $size =\n", join("\n", @chunk), "\n\n";
}

sub _array_chunk_it {
  my ($count, @array) = @_;

  return sub {
    my @chunk;

    for (1 .. $count) {
      push(@chunk, shift @array) if @array;
    } 

    return @chunk;

  } 
}
[download]

(Using a closure we can actually call _array_chunk_it multiple times, in an overlapping manner. Have multiple iterators running simultaneously. Plus it looks quite a bit nicer.)

this isn't something you should use recursion for

s/should/need to/

:) I meant should not, esp since there is nothing particularly recursive about it (you have to squint to make it recursive)

You also don’t need a module.

Sure I do :) otherwise I'm writing the the idiomatic perl solution

It was real hard to come up with

#!/usr/bin/perl --
use strict; use warnings;
my @x = ('a' .. 'z');
print yup( 5, @x ),"\n--\n";
print yup( 3, @x ),"\n";
sub yup {
    my( $n, @x ) = @_;
    my @yo;
    for( my $ix = 0; $ix < @x; $ix += $n )
    {
        my $high = $n - 1 + $ix ;
        $high > $#x and $high = $#x ;
        push @yo, join ' ', @x[ $ix .. $high ];
    }
    return join ",\n", @yo;
}
__END__
a b c d e,
f g h i j,
k l m n o,
p q r s t,
u v w x y,
z
--
a b c,
d e f,
g h i,
j k l,
m n o,
p q r,
s t u,
v w x,
y z
[download]

what goes here?

sub _array_chunk5 {
    my @arr = @_; 
    # Base case == when @arr is <= 5
    return ( join( " ",  @arr ) ) unless @arr > 5;
    # what goes here ?
    return ( join( " ",  splice ( @arr, 0, 5 ) ) , _array_chunk5(@arr)
+ );
}
[download]

But I might write it more like:

sub _array_chunk5x {
    my @arr = @_; 
    return ( ) if(@arr == 0);
    return ( join( " ", splice( @arr, 0, 5 ) ), _array_chunk5(@arr) );
}
[download]

    return (
        join( ' ', splice(@arr, 0, 5)) . ",\n" ,
        _array_chunk5(@arr),
     );
[download]

Update: Sorry, I did not notice that this is the same as IG's solution.