To work on $_ by default, check the size of @_. For example,
sub func { local $_ =   @_ ? $_[0] : $_;  ... } # copy
sub func { local *_ = \(@_ ? $_[0] : $_); ... } # alias

To request a scalar argument, use prototypes. For example,
sub func($)  { ... } # scalar
sub func(;$) { ... } # optional scalar
This is required for $str = my_uc my_reverse 'ab', 'cd'; to work.

Finally, use wantarray to determine whether a list or a scalar (or nothing at all) should be returned.

In Perl, your functions would be the following:

sub pp_lcfirst(;$) {
   local $_ = @_ ? $_[0] : $_;
   s/(.)/\l$1/;
   return $_;
}

sub pp_uc(;$) {
   local $_ = @_ ? $_[0] : $_;
   s/(.*)/\U$1/;
   return $_;
}

sub pp_reverse {
   if (wantarray) {
      my @rv;
      push(@rv, pop(@_)) while @_;
      return @rv;
   } else {
      my $str = join('', @_);
      my $rv = '';
      my $i = length($str);
      $rv .= substr($str, $i, 1) while $i--;
      return $rv;
   }
}

sub spaces_to_und(;$) {
   local $_ = @_ ? $_[0] : $_;
   s/\s+/_/g;
   return $_;
}
[download]

Update: Cleanup.

Update: Fixed the typo japhy noticed in my prototypes.

Shouldn't those $; prototypes be ;$ like spaces_to_und()'s?

---

Jeff japhy Pinyan, P.L., P.M., P.O.D, X.S.: Perl, regex, and perl hacker
How can we ever be the sold short or the cheated, we who for every service have long ago been overpaid? ~~ Meister Eckhart

Note that ;$ doesn't parse the same as a builtin like uc:

$ perl -we'print uc 1, 2'
12

$ perl -we'sub myuc(;$) { $_[0]||$_ } print myuc 1, 2'
Too many arguments for main::myuc at -e line 1, at EOF
[download]

Also, in the presence of my $_, myuc won't be able to see the right $_. Implementing a _ prototype is on the todo list, but not on any particular person's plate that I know of.

I know, but it's as close as possible. Considering the case that is different is an illegal case, I didn't bother confusing the issue by mentioning it.

my $_; doesn't compile for me with Perl v5.8.6. Did you mean tie $_? There's some kind of problem with local $_ when $_ is tied, but 1) that's not likely, and 2) it can be avoided by localizing *_ instead of $_ (as I did in one of my examples).

If @_ is empty, read from $_. Check wantarray()'s value when deciding what to do or what to return.

Prototyping? Am I missing something here? This seems to work:

sub mylcfirst {
    my $x;
    if (@_) { $x = join "", @_ }
    else    { $x = $_          }

    $x =~ s/(.)/\l$1/;
    return $x;
}

sub myuc {
    my $x;
    if (@_) { $x = join "", @_ }
    else    { $x = $_          }

    $x =~ s/(.*)/\U$1/;
    return $x;
}

sub myreverse {
    my $x;
    if (@_) { $x = join "", @_ }
    else    { $x = $_          }

    $x = reverse $x;
    return $x;
}

### sample1
$_      =   'lrep esu';
$str    =   myreverse mylcfirst myuc;
print $str."\n";

### sample2
$_      =   'lrep esu';
$str    =   mylcfirst myreverse myuc;
print $str."\n";
[download]

Sure, the code is a little clunky. And it doesn't take reverse in list context into account, but the idea is there. What part of this isn't what you are expecting?

myuc needs a prototype to handle $str = myuc myreverse 'lrep', 'esu'; appropriately. Same for myucfirst. See my reply.