I'm not sure why, but the last alternate ((.*)) seems to win in all cases when the other alternates use a look behind. However, things are much easier to understand if you look around less:

use strict;
use warnings;

my $regex = qr/(' ([^']*) ' | " ([^"]*) " | (.*))/x;

do_test (qq~No quote~); 
do_test (qq~'Single quote'~);
do_test (qq~"Double quote"~);


sub do_test {
   my ($line) = @_;

   print "\n";

   if ($line =~ $regex) {
           print "\$1 is $1.\n" if defined $1;
           print "\$2 is $2.\n" if defined $2;
           print "\$3 is $3.\n" if defined $3;
           print "\$4 is $4.\n" if defined $4;
   } else {
      print "No match.\n";
   }
}
[download]

Prints:

$1 is No quote.
$4 is No quote.

$1 is 'Single quote'.
$2 is Single quote.

$1 is "Double quote".
$3 is Double quote.
[download]

Note too various other tidy ups in the code, especially avoiding calling subs with & (which doesn't do what you think) and excessive use of \.

I'm not sure why,

At position 0,

1. (?<=\')(.*?)(?>\') can't possibly match (there can't be a ' before the first character),
2. (?<=\")(.*?)(?>\") can't possibly match (there can't be a " before the first character), but
3. (.*) always matches.

Since it matched at position 0, it doesn't try to match at position 1 (where one of the first two alternates has a chance of matching).

I forgot to mention that this regex is used repeatedly on the same string to parse out parameter and value pairs, such as the following:



radius = 3,
density = .014,
URL = "https://www.geometry.org",
max_no_of_attempts = 4
[download]


That is why the lookbehind and lookahead assertions are used, even though they cannot possibly match at the beginning or end of the overall parameter string, they can match at intermediate positions as the regex is used to walk over the value of the parameter string parsing out individual parm and value pairs.

Why are the first two alternatives not capturing quoted test strings?

Because your position is still at the string start so you can't use a lookbehind (or if you do it will never match). Simpler just to use this:

use strict;
use warnings;

use Test::More tests => 3;

my @strings = (
    'Now is the time',
    '"Now is the time"',
    "'Now is the time'",
);

my $regex = qr/^['"]?(.*?)['"]?$/;

for my $input (@strings) {
    my ($match) = ($input =~ /$regex/);
    is $match, 'Now is the time', "$input matched";
}
[download]

my $regex = qr/^['"]?(.*?)['"]?$/;

Note that this regex will also match oddballs like  q{'Now is the time} and  q{'Now is the time"}

---

Give a man a fish:  <%-{-{-{-<

Not a complete answer, but just a note:  (?>...) is not a positive lookahead (which would be  (?=...) instead), but is an "atomic" grouping (update: also called an "independent" subexpression) that affects backtracking. See Extended Patterns in perlre.

Oh, yeah, that was a typo. Thanks for catching.

use strict;
use warnings;
use Test::More tests=>3;
use Regexp::Common 'RE_ALL';
my @cases = (
    [q(Now is the time), 'unquoted'],
    [q('Now is the time'), 'single quoted'],
    [q("Now is the time"), 'double quoted'],
);

foreach my $case (@cases) {

    $_ = $case->[0];
    my $string
        = /\"(.*)\"/       ? $1
        : /\'(.*)\'/       ? $1
        : /[^"'].*[^'"]/   ? $&
        :                  'No Match'
        ;
    ok($string eq 'Now is the time', "$case->[1] found $string" );
} 

C:\Users\Bill\forums\monks>perl fireblood.pl
1..3
ok 1 - unquoted found Now is the time
ok 2 - single quoted found Now is the time
ok 3 - double quoted found Now is the time
[download]

It seems to me that this should work correctly (but can't test now on my mobile device):

my $regex = qr / "([^"]+)" | '([^']+)' | (.+) /x;
[download]