Hi, your problem description is not very clear. I think you are saying that you want to be able to handle arrays of varying lengths with a single sprintf statement. If so, you can always use the result of an expression as the format:

use strict;
use warnings;

my @slow_day = ( 4, 1..4 );
my @busy_day = ( 12, 1..12 );

for my $report ( \@slow_day, \@busy_day ) {
    my ( $total, @sales ) = @{ $report };
    my $fmt = 'Total: $%2d Sales:' . ' $%.02f' x scalar(@sales);
    print sprintf($fmt, $total, @sales), "\n";
}

__END__
[download]

$ perl 1223893.pl

Total: $ 4 Sales: $1.00 $2.00 $3.00 $4.00
Total: $12 Sales: $1.00 $2.00 $3.00 $4.00 $5.00 $6.00 $7.00 $8.00 $9.0
+0 $10.00 $11.00 $12.00
[download]

As to your second question: What happens when perl ... "runs out" of parameters (there are more variables to print than parameters in the format) ... Well, what happens when you try it? You can just use a one-liner for that:

$ perl -Mstrict -wE 'say sprintf("%s", qw/two strings/);'
[download]

Hope this helps!

> What happens when perl ... "runs out" of parameters

Note that C behaves the same, but bash doesn't:

$ printf '[%s]' two strings
[two][strings]
[download]

($q=q:Sq=~/;[c](.)(.)/;chr(-||-|5+lengthSq)`"S|oS2"`map{chr |+ord
}map{substrSq`S_+|`|}3E|-|`7**2-3:)=~y+S|`+$1,++print+eval$q,q,a,
[download]

Curious: I couldn't get an example C program calling printf("%s\n", "two", "strings"); to crash or display any errors under Valgrind or -fsanitize=address -fsanitize=undefined even with full optimization and with omitted frame pointers, despite it being undefined behaviour.

Not passing enough arguments in C for %s, though, causes a crash pretty quickly, because printf tries to interpret as a pointer something that was left on the stack from a previous function call, whatever it was. I got a lucky (null) a few times (stack had been filled with zeroes, and some C libraries handle NULL for %s as a special case, which is not required by the standard), then crashed on a different run when it tried to dereference address 0x1.

When dealing with lists and particularly intermediate lists in map/grep chains, it's sometimes difficult (or even impossible?) to know the number of list elements at runtime. This can be handled with yet another map expression:

c:\@Work\Perl\monks>perl -wMstrict -le
"print
   map  sprintf(q{`%s' }, $_),
   grep m{ \A [aeiou] }xms,
   qw(elements comprising this list unknown in advance)
   ;
"
`elements' `unknown' `in' `advance'
[download]

c:\@Work\Perl\monks>perl -wMstrict -le
"printf do {
   my @elems =
     grep m{ \A [aeiou] }xms,
     qw(elements within this list unknown in advance)
     ;
   qq/@{[ q{`%s' } x @elems ]}/, @elems;
   };
"
`elements' `unknown' `in' `advance'
[download]

It doesn't seem so. like others already demonstrated it's possible to build a repeated format with the x operator.

Personally I'd rather prefer to just do a for loop creating the output, hence avoiding to repeat myself

 
  DB<35> @a=1..10

  DB<36> printf "%03d:",$_ for @a
001:002:003:004:005:006:007:008:009:010:
[download]

please note that you can easily have other list constructors like map and grep in place for @a.

UPDATE: Corrected terminology. Thanks Hippo.

Note that Perl formats and sprintf are entirely different things. While the latter does not behave like Fortran with respect to repetition and numbers of arguments, the former is arguably somewhat closer.

You may also be interested in Fortran::Format and Fortran::F90Format.

my @_a=qw(one two three four damn it shut the door!);

printf "@{[q{'%s' } x @_a]}\n",@_a;
[download]

'one' 'two' 'three' 'four' 'damn' 'it' 'shut' 'the' 'door!'
[download]

The D language has the nesting  %( %) variadic array format specifiers (see std.format.formattedWrite). (I haven't followed up, but D often tracks C/C++ features, so the latest versions of these languages may have these specifiers also.) Any chance that Perl might get something like this?

> Any chance that Perl might get something like this?

Why? Perl has thanks to variable interpolation a huge flexibility, that's effectively a built in template language. Plus loads of operators to recombine strings.

What's the point overloading the printf formats with more syntax if we can already have it all in a short, expressive and canonical way?

  DB<90> sub format_n { my $n= shift; printf "%b" x $n ." ", splice @_
+, 0, $n while @_ }

  DB<91> format_n 3,(1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0)
101 100 101 010
  DB<92> format_n 4,(1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0)
1011 0010 1010
  DB<93> format_n 5,(1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0)
10110 01010 10000
[download]

(non-destructive version left as exercise)

Cheers Rolf
_{(addicted to the Perl Programming Language :)
Wikisyntax for the Monastery FootballPerl is like chess, only without the dice}

perl -Mstrict -we '
  my @arr = (0..10);
  printf("%d "x@arr, @arr);
'

__output__
0 1 2 3 4 5 6 7 8 9 10
[download]

or 'join' option...

perl -Mstrict -we '
  my @arr = (0..10);
  printf("%s", join(" ", @arr));
'

__output__
0 1 2 3 4 5 6 7 8 9 10
[download]

EDIT:

Yes, I know I could build an output string by looping over the array, but I am trying to learn about sprintf. :)

Sorry if 'join'-ish type option above was something OP already tried...