RFC 331 (v1) Consolidate the $1 and C<\1> notations

This and other RFCs are available on the web at
  http://dev.perl.org/rfc/

=head1 TITLE

Consolidate the $1 and C<\1> notations

=head1 VERSION

  Maintainer: David Storrs <[email protected]>
  Date: 28 Sep 2000
  Mailing List: [email protected]
  Number:  331
  Version: 1
  Status: Developing

=head1 ABSTRACT

Currently, C<\1> and $1 have only slightly different meanings within a
regex.  Let's consolidate them together, eliminate the differences, and
settle on $1 as the standard.

=head1 DESCRIPTION

Note:  For convenience, I am going to talk about C<\1> and $1 in this RFC.
In actuality, these notations extend indefinitely:  C<\1..\n> and
C<$1..$n>.  Take it as read that anything which applies to $1 also applies
to C<$2, $3>, etc.


In current versions of Perl, C<\1> means "whatever was matched by the
first set of grouping parens I<in this regex match>."  $1 means "whatever
was matched by the first set of grouping parens I<in the previously-run
regex match>."  For example:

=over 4

=item *
/(foo)_$1_bar/

=item *
/(foo)_C<\1>_bar/

=back

mean different things:  the second will match 'foo_foo_bar', while the
first will match 'foo[SOMETHING]bar' where [SOMETHING] is whatever was
captured in the B<previous> match...which could be a long, long way away,
possibly even in some module that you didn't even realize you were
including (because it was included by a module that was included by a
module that was included by a...). 

Probably the primary reason for this distinction is the following:

=over 4

=item *
s/(foo)C<\1>/$1bar/	# changes "foofoo" to "foobar"

=back

The key fact here is that, in the first section of a s/// you are supposed
to use C<\1>, but in the second portion you are supposed to use $1.  If
you understand the whole logical structure behind it and understand how an
s/// works (i.e., the right hand side of an s/// is a double-quoted
string, not a regex), you will understand the distinction.  For newbies,
however, it is apt to be quite confusing.

Aside from this confusion is the fact that, in general, when you use a
backreference you want it to refer to something that you just
matched...i.e., something from this regex.

To resolve all these issues, let's remove the C<\1> notation and
consolidate meanings as follows:

=over 4

=item *
C<\1> goes away as a special form 

=item *
$1 means what C<\1> currently means (first match in this regex)

=item *
${1} is the same as $1 (first match in this regex)

=item *
${P1} means what $1 currently means (first match in last regex)

=back

These changes eliminate a potential source of confusion, retain all
functionality, provide an easy migration path for P526, and the last
notation (${P1}) serves as a clear indicator that you are talking about
something from outside the current regex.

Using this new syntax, you could then write:

=over 4

=item *
s/(foo)$1/$1bar/			# changes "foofoo" to "foobar"

=item *
s/(bar)(bell)/${P1}$2/		# changes "barbell" to "foobell"

=back

=head2 Updating $1...When should it happen?

After a regex is finished, it must update the ${Pn} variables so that the
next match can access them if desired (if we wanted to get really
pathological, we could have multidimensional access such as:  ${P2,2}
which is the second capture from the second-to-most-recent regex.  This
would seem to be a Bad Idea, however).  This should not happen until after
the statement containing the regex is finished, in order that the $1
variables on the right hand side of an s/// will still refer to the
correct things.

=head1 IMPLEMENTATION

This may require significant changes to the regex engine, which is a topic
on which I am not qualified to speak.  Could someone with more
knowledge/experience please chime in?

=head1 REFERENCES

RFC 112: Assignment within a regex

RFC 276: Localising Paren Counts in qr()s.

perlre manpage