Piers Cawley writes:
> Stéphane Payrard <[EMAIL PROTECTED]> writes:
>
> > s/// in string context should return the string after substituion.
>
> Surely it should return the string after substitution, but with an
> appropriate 'but true' or 'but false' property depending on whether
> anything was substituted.
Perl 5 C<s///g> currently returns the number of substitutions made.
This has its uses, so Perl 6 C<s:e///> should probably continue to do
this.
Can we have a return value that stringifies to the result of the
substitution but numifies to the number of substitutions made and
boolifies based on the number rather than the string (to allow for
situations such as a successful substitution producing an empty string)?
Would we want that anyway? It means there's a difference between:
$substituted = $text ~~ s/$pattern/$replacement/;
if $substituted
and:
if $text ~~ s/$pattern/$replacement/
which doesn't sound like a great feature to leave lying around in a
language.
Thinking about this some more, I'm not convinced about Stéphane's claim.
Is it useful to return the substituted string? We already have the
substituted string in one variable (C<s///> doesn't work on a constant), so
what's the point in having it in a second one?
Often I want to modify a string and leave the _original_ behind in a
separate variable:
(my $modified = $original) ~~ s/$pattern/$replacement/;
but that's different, because the two variables end up with
(potentially) different contents rather than always being duplicates.
This, however, is irritating:
my @new = map { s:e/$pattern/$replacement/; $_ } @old;
I forget the C<; $_> far more often than I like to admit and end up with
an array of integers instead of modified strings. So I'd like a more
elegant way of writing that -- but I don't think making the return value
of C<s///> more complicated (and duplicating data in the process) would
be a nett gain.
It seems that the substituted text is needed only either in the original
variable or somewhere else, but not both. A variant of C<s///> which
did not modify the original but did return the modified string could
have some use. That'd allow things such as:
my $modified = $original ~~ ss/$pattern/$replacement/;
my @new = map { ss:e/$pattern/$replacement/ } @old;
except that C<ss///> is obviously a lousy name for such an operator.
I've no idea what a good name would be for distinguishing between
'modify yourself in this way and return how many times you did it' and
'return a copy of yourself modified in this way'; I fear that it'd be
too easy to get these confused and do the wrong thing.[*0]
Having an operator that substitutes and returns the modified string
would certainly have its uses, but unless a way can be found of doing
this which doesn't make other things worse, we'd just be rearranging the
inconveniences and introducing new pitfalls; on balance I think I'd
rather keep the pitfalls that I'm already used to avoiding than fix
those but have to learn about new ones.
[*0] I suppose it could be seen as analogous to the difference
between C<$count + 2> and C<$count += 2>. So maybe that's a precedent
for such distinctions and it wouldn't be that confusing after all
(C<~~> and C<~~=> anybody?). Or maybe the fact that learners often
get those different sorts of addition confused is a reason for not
going any further along this route and making matters worse.
Smylers
