$_ = "a\001b";
 m[(.)([^\1])] and print "$1|$2";
[download]

|b

There could be a way, but I'm not sure how, using the (?{...}) or (??{...}) constructs. I don't think I'd do it like that. Instead, I'd go for:

$_ = 'aaab';
m[(.)(?!\1)(.)] and print "$1|$2";
[download]

a|b

Yes. I'd kinda worked that out, and the lookahead assertion works ok, but I was really asking why don't they work in character classes? I mean there ae plenty of other ways of denoting a character, even the non-printable ones:

chr(0) => \cA, \01 \x01
[download]

It seems a shame to have to use a lookahead assertion and (.) to ([^\1])... and I was wondering if there was any reason other than "that's the way it is"?

---

Examine what is said, not who speaks.
"Efficiency is intelligent laziness." -David Dunham
"Think for yourself!" - Abigail

Because character classes are determined when the regex is compiled (which is different than when the Perl statement that contains the regex is compiled). There is no regex 'node' for "character class that consists of these hard-coded characters plus the characters in this backreference". The only character class regex node type is "hard-coded list of characters" that was built when the regex was compiled (not after it ran part way and figured out what $1 might end up being).

                - tye

I was wondering if there was any reason other than "that's the way it is"?

I can give you a few, hopefully informed guesses.

In your example, a backreference in a character class would seem to make sense, because you just matched one character. But what about longer strings? If your first group matched the string "a-z", would a character class with a backreference [\1] then have to match all lower case letters? Normal backreferences don't match as a regex, instead, they're substrings, and try to literally match what they're overlayed against.

What if your pattern matched just a single backslash, surely you'd end up with an invalid regex? Or would you instead prefer, that this would match "a", "-" and "z" only?

In any case, clearly, you'd need to have instant regex compilation, per attempt of a match. That isn't very fast. But it gets worse.

A character class can typically be implemented using a bitmap (or bit array), with single byte characters, that's 256 bits. To compile a character class, you just mark all the characters that are acceptable. To match using such a character class, just check to see if this character's bit is set in its bit array.

This also would seem to indicate that compiling a character class likely won't be the fastest part in a regex compiler. It's pretty obvious that a test using such a character class would be a lot faster, than the compilation. Just a tip to compare apples and oranges.

($_ = 'aaab') =~ m/(.)((?!\1).)/ and print "$1|$2";
[download]

a|b
[download]

$_ = 'aaaabbbccddee';
while (m/(.)(.)(??{$1 eq $2})/g)
{
    print "$1|$2\n";
}
[download]

a|b
b|c
c|d
d|e
[download]

Not so cool, but my way :)

perl -e'$_='aaabbbbccccdddd';print"$1|$2\n" while(m[(.)\1*(.)]g);'
[download]

($_ = 'aaab') =~ m[(.)((??{"[^$1]"}))] and print "$1|$2";
a|b
[download]

Abigail

That works too. The only problem with that was this came up whilst I was trying to tackle your "N-Queens with pure regex" problem. I thought I was onto a more efficient solution, but......it didn't work ;)

---

Examine what is said, not who speaks.
"Efficiency is intelligent laziness." -David Dunham
"Think for yourself!" - Abigail

$_ = 'aaabbbbbbbbbbbbbccccccccccccccccccccc'; 
print "$1|$2\n" while (m[(.)(?>\1+)(.)]g);
[download]