That should read that you must use the scalar function to find the count in list context... The scalar function simply puts its argument in scalar context, independent of the external context.

Your usage is correct, though you would get a surprise if you changed the concatenation dots to commas for efficiency. That would put @foo in list context and you'd get the array contents spilled to the selected handle.

To explain the "Do what I mean" behavior you show in your example......
It makes no sense for a list to be operated on by the concatenation operator. The concatenation operator takes a scalar on both sides. Thus, if you were able to call "wantarray" on the concatenation operator you would find that it doesn't "want a list." That fact forces the @foo array to be evaluated in scalar context, and the results of that evaluation to be concatenated with whatever is on the other side of the "." operator. As we all know, the good book says, "There is no such thing as a list in scalar context." When you put an @array somewhere that a scalar is expected, you get the behavior documented for @array in scalar context; you see how many elements it contains.

If, on the other hand, you say, print @foo you will see that print accepts a list (and prints a list). If you could call wantarray (an apparent misnomer with origins in the dark ages when lists were called arrays too) on "print" it would return true. And so, @foo is evaluated in list context when evaluated as an arguement of 'print'.

The most peculiar thing I can think of in all this is the fact that concatenation operator doesn't accept a list while variable interpolation into a string does. I know that "concatenating" lists is what join is for. But to a relative greenie like me, it seems inconsistant. (For example, "This @array interpolates as a list.")

Perhaps our lives are simpler and better because arrays inside of literal strings are seen as arrays in list context, but nevertheless, why that "works" when concatenation doesn't is something that the real experts will have to reveal.

The concatenation operator takes a scalar on both sides.

This is correct as far as it goes, but the truth is more specific...

The most peculiar thing I can think of in all this is the fact that concatenation operator doesn't accept a list while variable interpolation into a string does. I know that "concatenating" lists is what join is for. But to a relative greenie like me, it seems inconsistant.

You're missing a small bit of the contextual richness that makes Perl so cool. The binary concatenation operator evaluates its left and right arguments in string context, which happens to be a particular variety of scalar context. You can see this difference for example if you concatenate $!

$! = rand(7);  print("In numeric context it's ".
   ($!+0)." but in string context it's " . $! . $/);
[download]

The join function is a list operator, like print. It evaluates each argument in string context, but it takes those arguments as a flattened list. You can write your own function that does this:

  sub listop {
     my @result;
     for (@_) {
        push @result, "".$_;
     }
     @result;
  }
[download]

#update: or, more concisely, sub listop{map{"".$_}@_}

You can pass this thing an array or list (or several arrays or lists), and it will return a list containing all the elements, with each one stringified. This is basically what join and print do, except that rather than returning that list they do something interesting with it.

---

$;=sub{$/};@;=map{my($a,$b)=($_,$;);$;=sub{$a.$b->()}}
split//,".rekcah lreP rehtona tsuJ";$\=$ ;->();print$/
[download]

I am a perl newbie. I wanted to confirm few things based on your answer. Here are my questions

1. The operation ($!+0) causes $! to be evaluated in numeric context because of the binary + operator. The parenthesis around $!+0 are necessary here because of the preceeding concatenation operator which is left associative and has the same precedence as that of binary + operator. Now, once $!+0 is evaluated in numeric context, to say number 2, does it again get evaluated in string context by the preceeding concatenation operator to string of one character i.e. "2" ?

2. Within a string, say "Hello World!", the default context is string context. So if I have,

@array = (perl, monks);
print "Hello @array World!";
[download]

@array is evaluated in string context inside "Hello @array World!" so as to yield a single string "perl monks" which is then interpolated into "Hello World!" so as to give "Hello perl monks World!".
Is this observation true? and is this what you are refering to as the "flattaned list" the join operator accepts ?

3. Why does

print @array;
[download]

prints: perlmonks
instead of: perl monks ?

4. What are all the contexts (like numeric context, string context) that exist which are variations of scalar context or list context?

I understand now, thank you all.