Perl as a functional language

• Nested functions.
• Lexical scope.
• Functions as values, which can escape.
• Anonymous functions.

I present here a bit of (actually useful) perl code (without much documentation, of course).

#! /usr/local/bin/perl -w

# Call as:  mpid string1 string2 ... /regexp1/ /regexp2/ ...
# Prints the PIDs of all processes whose `comm' contains one of the 
# strings, or matches one of the regexps.  As such, it is a more
# flexible version of pidof.
#
# Assumes a Unix system with SysV-style ps(1), supporting the -o
# argument and the `comm' field.  Tested on Linux (procps 2.0.0) and 
# Solaris 7.

use strict;

# Call as:  any { predicate } @list
# Returns true if the predicate returns true for any element of the list.
# The predicate is called as a function of one argument---this is different
# from the norm for perl operators, where the predicate would be called with
# $_ bound to the list element.  Note that modifying $_[0] in the predicate
# code will modify the elements of the list.
sub any(&@) {
        my $pred = shift;
        foreach my $x (@_) {
                my $y = $pred->($x);
                return $y if $y;
        }
        return 0;
}

# If passed a string of the form "/regexp/", returns the same string
# with the // removed.  If passed a string of any other form, returns
# the string with regexp metacharacters quoted.
sub refix($) {
        local $_ = shift;
        return $1 if m,^/(.*)/$,;
        return quotemeta($_);
}

open(F,"ps -e -o pid,comm|");

print join " ",
 map { $_->[0] }
  grep { any { my $x=refix shift; $_->[1] =~ /$x/ } @ARGV }
   grep { defined $_->[0] and defined $_->[1] }
    map { [/^\s*(0-9+)\s+(.*)/] }
     map { (/(.*)\n$/)[0] }
      <F>;
print "\n";
close F;
__END__

One irritating problem with using Perl functionally is that $_ is always dynamically scoped---and things like grep and map use it, rather than simply taking a function of one argument as they (or their counterparts) do in most languages. For example, if you were to modify any above to use map, it would interfere with the use of `$_->[1]' in the first grep. The best way to deal with this is to write your own versions of map, grep, etc. Well, that's the second-best way. The best is to use another freaking language. But I digress.

Another problem---even worse, perhaps---is the lack of formal parameters, and the specialness of @_, but that is a rant for another day.

See also: Schwartzian transform.