I think you've missed something.

1. This is somewhat more of a feature. If you want to extract all matches from a regex, you can do @a=/regex/g and get all the strings that match. If you want the count, you could do $a=()=/regex/g;.
2. From perlre:

   Perl defines the following zero-width assertions:
   \G - Match only at pos() (e.g. at the end-of-match position of prior m//g)

   In other words, if the regex starts with \G the match has to start at pos or the regex doesn't match.
3. m//g shouldn't reset in scalar context until it fails. Otherwise you couldn't do loops such as while ($string =~ /regex/g) { ...

Perl Idioms Explained - @ary = $str =~ m/(stuff)/g by tachyon should help with regexes in list context.

Hope this helps.

In scalar context m//g doesn't return size of the list it would give back when called in list context,

If you want the number of elements in the list returned by a pattern with the /g modifier when evaluated in list context, you can use a list assignment in scalar context, which produces the number of its elements. In this case, we assign to an empty list:

$_ = "456";
$count = () = /./g;
print $count;
# prints 3
[download]

Your test output is entirely expected behavior according to the documentation. Perhaps it would be better if you indicated what you expected the output to be.

1. m//g returns true or false in scalar context.
2. \G is not useless.
3. m//g won't reset pos() until the match fails.

I had recently answered a post, Re: An Insane Typo Bug, and it relates to your question in an interesting way. The original post in that thread has a totally different face with your wonder, but both are about the same fact that, in scalar context, m// returns either 1 or 0.

For pos(), try this, it gives you 1 and 9, so pos() does work:

use strict;
use warnings;

$_ = "0123456789";
my $ret = m/0/g;
print "ret = $ret, pos = " . pos() . "\n";
$ret = m/8/g;
print "ret = $ret, pos = " . pos() . "\n";
[download]

<pedantic> actually, m// in scalar context returns either 1 or "" (empty string). </pedantic>.

You are very close to 100% right. However I do observe something else, and I don't let things escape easily.

If I do this:

use strict;
use warnings;

{
    $_ = "1234";
    my $ret = /2/g;
    print "($ret)\n"
}
{
    $_ = "1234";
    my $ret = /9/g;
    print "($ret)\n"
}
[download]

The outputs are 1 and "empty string", which indicate that you are right.

However, try this:

use strict;
use warnings;

{
    my $a = 0;
    print "(" . ~$a . ")\n";
}
{
    my $a = 1;
    print "(" . ~$a . ")\n";
}
{
    my $a = "";
    print "(" . ~$a . ")\n";
}
[download]

It returns:

(4294967295)
(4294967294)
()
[download]

Remeber the return values for zero and empty string, and then try this:

use strict;
use warnings;

{
    $_ = "1234";
    my $ret;
    print ~ m/2/, "\n";
}
{
    $_ = "1234";
    my $ret;
    print ~ m/9/, "\n";
}
[download]

It gives you:

4294967294
4294967295
[download]

Which indicates the "~" operator does receive 0, not "empty string". Rememebr that in the case that we explicitly pass "~" an empty string, it is not converted to 0

However, if we do this:

use strict;
use warnings;

{
    $_ = "1234";
    my $ret;
    print ~ ($ret = m/2/), "\n";
    print "($ret)\n";
}
{
    $_ = "1234";
    my $ret;
    print ~ ($ret = m/9/), "\n";
    print "($ret)\n";
}
[download]

You get:

4294967294
(1)
4294967295
()
[download]

It seems that although $ret receives "empty string", "~" operator receives 0, again rememebr that we didn't see this kind of auto-convertion in the explicitly-passing-empty-string case.

In scalar context m//g doesn't return size of the list it would give back when called in list context,

my $s = "123 45 6 789";
while ($s =~ m/\d+/g) {
  print "> $&\n";
}
[download]

> 123
> 45
> 6
> 789
[download]

2.The \G anchor is useless - perlre states, that it should be used only at the beginning of pattern,

my $s = "123  carrots   45 6  bananas 789";
while (1) {
  $s =~ /\G(\d+)/gc and print "NUMBER $1\n" and next;
  $s =~ /\G\s+/gc and print "SPACE\n" and next;
  $s =~ /\G([a-z]+)/gc and print "WORD $1\n" and next;
  $s =~ /\G$/gc and last;
}
[download]

NUMBER 123
SPACE
WORD carrots
SPACE
NUMBER 45
SPACE
NUMBER 6
SPACE
WORD bananas
SPACE
NUMBER 789
[download]

NUMBER 123
NUMBER 45
NUMBER 6
NUMBER 789
[download]

3.and most important - m//g in scalar context doesn't reset pos (matches only once).

Consider this:

my $s = "123  carrots   45 6  bananas 789";
while ($s =~ /(\d+)/g) {
  print "'$1' at position ", pos($s)-length($1), "\n";
}
[download]

'123' at position 0
'45' at position 15
'6' at position 18
'789' at position 29
[download]

my $s = "123  carrots   45 6  bananas 789";
while ($s =~ /(\d+)/g) {
  print "'$1' at position ", pos($s)-length($1), "\n";
  pos($s) += 13;
}
[download]

'123' at position 0
'5' at position 16
'89' at position 30
[download]

I ask you if it's proper behaviour / undocumented feature / bug? Or maybe I have missed something?

I hope this helps, but I'm not sure what your objection is, so I can't address it directly.

--
Mark Dominus
Perl Paraphernalia