I'll take the first one, but I haven't played with forks so I'll leave that to wiser monks.

s/\A\s+//, s/\s+\z//
[download]

The \A and \Z are just like "^" and "$", except that they won't match multiple times when the /m modifier is used, while "^" and "$" will match at every internal line boundary. To match the actual end of the string and not ignore an optional trailing newline, use \z.

The other bit:

for my @r = @_;
[download]

Update: There are a couple of other things worth mentioning. The way the for loop is constructed, the default variable $_ is used (see perlvar), which aliases the elements in @r. Second, the final line, which contains a solitary @r, is a shorthand way of specifying the return value of the routine (remember, the elements of @r were changed via aliasing in the for loop). See perlsub:

If no return is found and if the last statement is an expression, its value is returned.

Oh! I see now. This:

s/\A\s+//, s/\s+\z// for my @r = @_;
[download]

is the same as

my @r = @_;
s/\A\s+//, s/\s+\z// for @r;
[download]

Thanks!

sub strip {
    s/\A\s+//, s/\s+\z// for my @r = @_;
    @r
}
[download]

I'm not concerned with forking code here, per se. What I'd just like to know is, what does something like

foo {
    bar {
        ...
    }
    baz {
        ...
    }
}
[download]

even mean? I know what $, @, %, and & signify, and I know what sub {...} gets me, but it's just completely flying over my head what I'm looking at here with these barewords followed by code in curlies. Am I missing something obvious? :)

As colwellj pointed out, that bit of code is documented in Proc::Fork

I didn’t aim for clarity in that bit. I wanted to waste the least space possible on code to perform this function, because I was contrasting with Ruby and Python examples, where there is no need to write any code for this because both languages include strip methods in their built in String classes.

Maybe I should lobby for the inclusion of a strip function in Scalar::Util. (It could even be written in XS, and therefore go faster than regexes. Hmm. There’s a thought.)

Makeshifts last the longest.

Is it just me or does the whole bunch of Utils modules seem very haphazard, from namespace choices to grouping

run_fork and child are function calls declared with the & prototype (See perlsub: Prototypes). So, yes, they auto-subify their first argument (as though you had called run_fork(sub { ... })).

Ohhhhhh. I see. Thank you for pointing that out! I've avoided using Prototypes in my own code, and had almost forgotten about them.

FWIW, I much prefer the more explicit syntax that you gave as an equivalent example. That is, something like this seems sensible and obvious to me:

#!/usr/bin/env perl

use strict;
use warnings;

sub call_it {
    my $fn_ref = shift;
    &{$fn_ref}();
}

call_it( sub { print "hi\n"  } );
call_it( sub { print "bye\n" } );
[download]

If you understand map { foo($_) } then this code shouldn’t give you any trouble.

Makeshifts last the longest.

Just for completeness’ sake, that strip function code is a condensed syntactic (near) equivalent of this function:

sub strip {
    my @r = @_;
    for ( @r ) {
        s/\A\s+//;
        s/\s+\z//;
    }
    return @r;
}
[download]

But I didn’t want to spend 6 lines on a routine that is completely incidental to the main point of the code, and which I put there only to emulate the exact behaviour of the Ruby and Python counterparts. If it were in a module with string functions, I would write it in the long-hand form. Programming is writing and code is literature. Sometimes you need to linger on the details and sometimes they would only derail the pacing.

Makeshifts last the longest.