TT has some nice meta information included in all loops (size, max, index, count, first, last, prev, next). I think this is much easier to read than the slice stuff-

[% FOR item IN my_stuff %]
.[% item %]([% item %])[% "," UNLESS loop.last %]
[% END %]
[download]

You can also bake this stuff into your templates if you want.

use Template::Stash;
$Template::Stash::LIST_OPS->{my_weird_join} = sub {
    join(",\n", map { "$_.($_)" } @{ +shift || [] };
};
# then...
[% my_stuff.my_weird_join %]
[download]

Not tested but looks right.

Ah, thanks! Both look quite interesting. I will check them out. Template seems to be quite powerful.

Great. I adore TT and this example goes to the root of why and why I break from the View purists who say TT is a disaster and you should use something like HTML::Template. These simple loop controls can solve many common display logic problems.

TT can do just about anything. Beware of moving too much into it (it can write files, run macros, run plain Perl, do recursion, etc, etc, etc). If you want a ton of code in templates, Mason is probably the right choice. TT lets you separate and plugin really well though so you can do your own methods and filters, for example, without writing anything but glue code; The Right Way to Do It™. Just another example-

use warnings;
use strict;
use Template;
use Lingua::EN::Numbers::Ordinate "ordinate";

my %config =
    ( FILTERS => {
                  ordinal => sub { ordinate($_[0]) },
                  ordinal_html => sub {
                      my $ord = ordinate($_[0]);
                      $ord =~ s,(\D\D)\z,<sup>$1</sup>,;
                      return $ord;
                  }
                 }
    );

my $tt2 = Template->new(\%config);

$tt2->process(\*DATA, { numbers => [ 0 .. 121 ] })
    or die $tt2->error;

__DATA__
[% FOR i IN numbers %]
  Plain: [% i | ordinal %] -- HTML: [% i | ordinal_html %]
[%-END %]
[download]

I'd also point you toward Template::Alloy. It's a well behaved implementation of the TT2(3) syntax with a few improvements and supports several other template types. I've used it on my last couple of projects and haven't hit any reasons to go back.

I now implemented this as follows. I also added alignment of the listed names by calculating the maximum length.

Is there any possibility to get the indention level of the template code, so that all produced lines are indented the same amount (by adding the number of spaces in join( ))?

Thanks again.

Update: I know fixed the indention problem by (re-)adding a join argument:

use Template::Stash;
use List::Util qw(max);

$Template::Stash::LIST_OPS->{signal_list} = sub {
    my $aref = +shift || [];
    my $sep  =  shift || "\n  ";
    my $l = max map { length $_ } @$aref;
    join(",$sep", map { sprintf ".%-${l}s (%-${l}s)", $_, $_ } @$aref)
+;
};
[download]

It looks like you want to do the same thing to each item in the list except the last item, right? I think:

[% FOREACH n in names.slice(0,-2) %]  
.[% n %]([% n %]),
[%- END %]
.[% names.last %]([% names.last %])
[download]

Would do what you want. See Template::Manual::VMethods for more. The above is untested, so play around until it actually works.

Update: s/slice(0,-1)/slice(0,-2)/

It fails if the list has zero elements. It's getting complicated fast, which is why I didn't post that solution.

Thanks, this works (with .slice(0,-2)). I was simply thinking the wrong way. The fact that the format must be used twice is a little drawback, but I think it does not get much shorter.

It is a pity that the Template module does not provide a 'map' virtual method, otherwise a 'list.map(...).join(...)' would be possible.

The fact that the format must be used twice is a little drawback,

You could use a [% BLOCK %] to remove the redundancy.

my @out = join (",\n", (map {".$_($_)"} (@myarray)));
[download]

si_lence

Thanks, but I know the Perl code to do it. I was looking for the Template code which I can use inside a template file.

oops, misread your question. sorry!