perl: Specify record separator with -n/-p (\0, if no argument).

Map program over already available @ARGV (from command line or previous -A) or undef. If you wrap program in {} uses grep instead of map. The result becomes the new @ARGV. You can mix it with -B. The 1^st two are equivalent, except that the 1^st one isn't limited by Shell line length limitations. The third again greps by file size, reading only the Perl modules less than 1 kB:

pl -nA '<*.pm>' '...'
pl -n '...' *.pm
pl -nA '<*.pm>' -A '{ (stat)[7] < 1000 }' '...'

perl: Autosplit mode with -n/-p (splits $_ into @FIELD).

Run program before reading a new file in -n/-P/-p.

Add program before main program in same scope. You can use it to initialise my variables. Whereas, if you define a my variable in the main program of a -n, -p, -P, -o, or -O loop, that's a new variable on each iteration. This doesn't do a BEGIN block unless you wrap program in {}. You may mix it with -A.

perl: Check syntax only (runs BEGIN and CHECK blocks).

perl: Enables the listed Unicode features.

Colorize (people with impairment may adapt their system, terminal, or browser) some of the output; when can be never, always, or auto (the default).

perl: Run program under debugger.

perl: Set debugging flags (argument is a bit mask or alphabets).

Run program after finishing reading a file in -n/-p.

Add an END block after main-program in same scope. So, my-vars work as follows: the END block is a closure of the 1^st $inner variable. Perl warns "Variable "$inner" will not stay shared":

pl -OB 'my $outer' -E 'echo $inner, $outer' 'my $inner = $outer = $ARGV' a b c

pl -OB 'my $outer' -E 'e $inner, $outer' 'my $inner = $outer = $A' a b c

a c

perl: Don't do $sitelib/sitecustomize.pl at startup.

perl: Provide split() pattern for -a switch (//'s are optional).

perl: Specify @INC/#include directory (several -I's allowed).

perl: Edit <> files in place (makes backup if extension supplied).

perl: Assume while (<>) { … } loop around program. It's a little richer than that: if you use last, it closes the current file, leaving you to continue the loop on the next file.

Assume for(@ARGV) { … } loop around main program, and $ARGIND (or $I) is the current position. In this case -p doesn't imply -n. If you give number, passes that many args at once as an array, referencing the original values. If there aren't enough on the last round, fills up @ARGV with undefs.

pl -opl '' I II III IV
pl -o3 'echo $ARGIND, @$_' i ii iii iv v vi vii viii ix

pl -opl '' I II III IV
pl -o3 'e $I, @$_' i ii iii iv v vi vii viii ix

I
II
III
IV
0 i ii iii
3 iv v vi
6 vii viii ix

like -o but use @ARGV as loop variable.

perl+: On each loop print (also -o and -O, in which case you must fill $_) iteration. If you give number, prints at most number times.

Like -p but print only if main program evaluates to true, like grep.

Reset $. and -p/-P counter for each file.

perl: Enable tainting checks.

perl: Enable tainting warnings.

perl: Allow unsafe operations.

perl: Dump core after parsing program.

perl: Print version, patchlevel and license.

Rerun with given perl version, which is just a string appended to perl.

perl: Enable all warnings.

perl: Enable many useful warnings.

perl: Disable all warnings.

Benchmark slow code for 10 s, display name, looping over args.

Same but run code 100 times in benchmark, to reduce overhead.

Import and return %Config, e.g., Config->{sitelib}, optionally only part matching regexps.

Date (from arg [s, us], s{.us}, offset [+-]s{.us}, tz ([+-]0-14{:mm|.ff}). You should pass microseconds as strings because floats have implementation-dependent rounding issues. You must pass positive offsets as strings because otherwise it loses the +. Returns the date, if called in some context, else echoes it.

pl 'Date;
    $_ = Date -86400, "+3600";
    echo $_, " -- ", Date "+8:45"'

pl 'D;
    $_ = D -86400, "+3600";
    e $_, " -- ", D "+8:45"'

Mon Aug 14 23:34:20.425194 2023
Mon Aug 14 00:34:20.425292 2023  --  Tue Aug 15 06:19:20.425333 +08:45 2023

Echo prettified args or $_ with spaces and newline. Prettified means, undef becomes that string, italic if --color is active. Anything that can be stringified, is. Any other reference goes through Data::Dumper, which pl loads only if needed.

If it's called in scalar context (e.g., $x = echo …) instead return the same as it would echo, in one string (inspired by Shell $(…)). If it's called in list context (e.g., @l = echo …) return each arg prettified individually, with a newline on the last one.

Same but no newline.

Form(at) and echo prettified args or $_ with newline. If it's called in scalar or list context (e.g., $x = form …) instead return the same as it would echo, in one string. Parameter index can be "%1:" instead of "%1\$".

Same but no newline.

Same as Date but uses ISO format.

pl 'Isodate;
    $_ = Isodate 7 * -86400;
    echo $_, " -- ", Isodate "+8.75"'

pl 'I;
    $_ = I 7 * -86400;
    e $_, " -- ", I "+8.75"'

2023-08-14T23:34:20.462578
2023-08-07T23:34:20.462666  --  2023-08-15T06:19:20.462695 +08:45

Store value or chomped $_ in $KEYDIFF{key or $1}[$ARGIND]. At the END for each key (which pl sorts numerically if possible) pl diffs all values.

Same but key is $FIELD[number] or $F[0].

Trim hash_or_array (default %NUMBER) values less than n (default 2), or, if negative, more than -n e.g., -EN or -E 'Number -5, @RESULT'. This happens recursively at any depth in nested hashes or arrays.

The first argument can also be a function, where deletion happens for every element where it returns a falsy value. It gets called for each scalar element with 3 arguments: 0 - the current (nested) hash or array, 1 - its key or index, 2 - its value.

pl '%RESULT = (neg => [-9..-1], pos => [1..9]); Number sub { ! ($_[2] % 3) }, %RESULT'

pl '%R = (neg => [-9..-1], pos => [1..9]); N sub { ! ($_[2] % 3) }, %R'

neg:  [
  -9,
  -6,
  -3
]
pos:  [
  3,
  6,
  9
]

Open pipe from cmd and loop over it.

Replace values from hash in template (defaults to $_), which may also be a filehandle of ref to a filename. Hash (defaults to %TEMPLATE) may be given as a reference or key-value pairs. The template may use one of three markup styles: [% x %], {{ x }}, or <?pl x ?>. These are totally equivalent. The 1^st one found in the template will be used. If you put a ~ just inside a delimiter (e.g., <?pl~ x ~?>), it will gobble horizontal whitespace on that side, behind also one newline.

Within the markup x may be any valid syntax for a Perl hash key. The 3 characters |, :, or ! mark the end of the key name and introduce 3 kinds of filter. The 1^st two, can be ?| or ?:, meaning this item applies only if the key exists. Otherwise the key is optional. If you give a key, its value is locally assigned to $_. If undef it defaults to ''.

You write the filter in Perl. You can abort the filter with last. If the filter starts with | then you pipe its scalar value into the template. If there is no filter after |, you recursively treat the value as a template. If the filter starts with : then you insert the value of $_. An easy way to only do that is [%:%]. The whole template gets compiled to an anonymous sub, the 1^st time. As this happens inside the function, filters have no access to your surrounding my variables.

You insert the Perl code following ! into the code the template compiles to verbatim. This is useful for flow control. E.g., if $TEMPLATE{x} (or $T{x}) is an array, you can loop over its values as @$_. The loop logic is entirely in Perl, which again localizes $_. If do-nothing [%!%] starts the document, it "declares" its markup syntax. And with ~ it suppresses surrounding space including one following newline. (See PLDUMP)

pl 'template q(A: {{ a }} B: {{ | "no" }}{{ b ?| "yes" }} C: {{ lc "C" }} C+1: {{ c|$_ + 1}}), qw(a 1 c 3)'
pl 'template q([%x!for( @$_ ) { %] X: [% : %] [%~ ! } %][% y %]), { x => [1..5] }'
pl 'template q(<ul><?pl l!for( @$_ ) { ?> <li><?pl:?></li><?pl ! } ?> </ul>), { l => [1..3] }'

pl 't q(A: {{ a }} B: {{ | "no" }}{{ b ?| "yes" }} C: {{ lc "C" }} C+1: {{ c|$_ + 1}}), qw(a 1 c 3)'
pl 't q([%x!for( @$_ ) { %] X: [% : %] [%~ ! } %][% y %]), { x => [1..5] }'
pl 't q(<ul><?pl l!for( @$_ ) { ?> <li><?pl:?></li><?pl ! } ?> </ul>), { l => [1..3] }'

A: 1 B: no C: 3 C+1: 4
 X: 1 X: 2 X: 3 X: 4 X: 5
<ul> <li>1</li> <li>2</li> <li>3</li> </ul>

Same but no newlines, also not on nested templates.

pl '$_ = q( [ <?pl~inner|~?> ]);
    $TEMPLATE{inner} = q([ {{ who | $_ || "Jack" }} in the box ]);
    Template;
    $TEMPLATE{who} = "Sue";
    template'

pl '$_ = q( [ <?pl~inner|~?> ]);
    $T{inner} = q([ {{ who | $_ || "Jack" }} in the box ]);
    T;
    $T{who} = "Sue";
    t'

 [[ Jack in the box ]] [[ Sue in the box ]
]

perl: ARGV, $ARGV & @ARGV are all aliased to A, $A & @A.

Index of ARG which -o, -n, or -p loop is currently processing.

perl: This is an alias to loop autosplit variable @F.

Predefined to a single quote ' without any magic. Perl's q() makes it easy to integrate functional quotes under all circumstances. This does the same for literal quotes.

Predefined to a double quote " without any magic. Perl's qq() makes it easy to integrate functional quotes under all circumstances. This does the same for literal quotes.

At END, sort by keys, print keydiff of $ARGIND array elements. Filled by keydiff.

At END, sort numerically by values.

At END, echo $RESULT if defined, then @RESULT one per line if not empty, then %RESULT sorted by keys.

Since pl -MO=Deparse won't show your parts of the program, it can be quite baffling when things go wrong. If you export this with value 1 before starting pl, you see how your parts get embedded in various bits of generated stuff. If you install perltidy, pl will use it. Some options get handled by perl, so they won't show up here:

PLDUMP=1 \
    pl 'say "Hello Perld!"'

use feature ':' . substr $^V, 1;

sub pl::prog {
    $pl::last = 1;
  LINE: {
#line 1 "main program"
        say "Hello Perld!";
    } continue {
        $pl::last = 0;
    }
    if ( $pl::last || eof ) {
        ++$ARGIND;
        if ($pl::last) { my $d = $.; close ARGV; $. = $d }
        exit if $pl::last == 2;
    }
}

If you export this with value 2, it will instead show what a template would compile to:

PLDUMP=2 \
    pl 'template q([%x!for( @$_ ) {%] X: [% : %] [%~!}%]), x => [1..5]'

PLDUMP=2 \
    pl 't q([%x!for( @$_ ) {%] X: [% : %] [%~!}%]), x => [1..5]'

my @_template = [
  '',
  ' X: ',
  ''
] ;
#line 1 "template"
sub { my $_template = $_template[0]
; for((local $_ = $TEMPLATE{x} // '')?():(), @$_ ) {
;$_template .= $_template[1] . (do {{ 
; $_ }} // '');$_template .= $_template[2]
; }
;
; $_template }