kj0> I was hoping to get the number of files having a particular format by
kj0> using:

kj0>   my $n = glob("${prefix}*");

kj0> but NOOO!  Instead, in this case Perl puts the first element of the
kj0> array in $n, instead of the size of the array.

Why would you have thought this?  There are *more* operators that do
*not* return the "size" in a scalar context than do!  So "size" is the
exception, not the rule.

grep(), split() (with odd side effects) and I forget the other one or
two.  But many others don't, such as glob or getpwnam or comma or
literal slice or regexp match or filehandle read or.....

Remember - returning a size-count is the *exception*, not the rule!

print "Just another Perl hacker,"

It's that leap that seems to be the norm in most of the Perl docs out
there.  To blur a list with an array name is damaging, as you
discovered.  We're very careful in the classes we teach to distinguish
those.  Llama 3 will go even further to break them apart, as we've
found a whole new way to prevent people from ever thinking about

unless Randal and rootbeer have come up with a new new way, we
introduce arrays in terms of single element access before we talk
about operations on the array as a whole. beat all of that into
the students heads before you show them a slice.

think about
$line = <STDIN>;

glob() works like this.

tina

Tina> if there is an array returned from a function,

See, it's sloppy talk like that that gets us all in trouble.
You cannot return an array from a function.  The action of:

only a list or a scalar.

Maybe this is why the newbies get confused.  We have sloppy talk, and
then that gets quoted as real, and then the bad book authors start
using that, and then the newbies get very confused.

A list is a temporary sequence of values.  Functions returns lists.
Functions are passed lists.  You can't change the length of a list.
Lists are very very transient things.

An array is a particular data structure in memory.  You can change the

Most of the time in Perl we use arrays because they act as containers
for lists.  We can store a list of values in an array, then fetch the
list of values when we call a function:

The trick is to remember that most things in Perl that act on multiple
values expect lists, not arrays.  The only exceptions are the functions
specifically for arrays: push, pop, shift, unshift, splice.  (There
might be more but they don't come to mind right now, he says hedging
his bets).

A rough analogy for C people is that lists are temporary things
allocated on the stack around function calls, while arrays are
malloc()ed things in the heap.

Cheers;

   sub foo
      {
      if( wantarray )
         {
         return ('This value', 'That value', 'Most used value')
         }
      else            
         {
         return 'Most used value'
         }
      }

which clearly contradicts what you claimed.

or more logical, I said:
(sub returns always list) =>
             (call in scalar context will give you the size)

you assumed I said:
(sub returns a list or scalar) =>
             (call in scalar context will give you the size)
which is of course wrong.

if i know the wantarray function you could
assume i know what i can do with it =)

regards,
tina

        print (qw/Sun Mon Tue Wed Thu Fri Sat/)[(localtime)[6]];
        print join(':', reverse( (localtime)[0..2] ) );

And of course, you can use an array almost anywhere you can use a list;
it's just not an array anymore.  However, you cannot use lists anywhere
you can use arrays; eg, push(), pop().

Any intricacies of the differences I better leave up to Larry, Randy,
or Tom (if they still follow this NG).  Beyond this I can't help you
much.  What I can say is that this blurred distinction between the
two is more a blessing than anything (to me, anyway).

Alright, an unindexed C array simply returns a pointer to the first
element of the array.  Is this what you're referring to?

[Begin OT section]

Consider:

: #include <stdio.h>
:
: void main() {
:       char* str = "arbitrary";
:       printf("%c\n", str[1]);
: }

After running this little program, I was reminded of how interchangeable
C char arrays and char pointers are.  However, AFAIK this only applies
to char[] and char*.  I've found that indexing a dereferenced int*:

        int* x = new int(5);
        x[0];

...does not cause any errors.  But any attempt to _use_ the indexed pointer
caused a segmentation fault.

OTOH, the college professor who taught my C++ class was unaware of this
interchangeability. (Either that, or he didn't want to confuse
anyone...yet.)  =)

[End OT section]

   sub foo { return ( 1, 2, 4 ) }
   my $value = foo();
   print $value;

now, try to explain that result in terms of what you just said.

so what about
"if the sub returns a copy of an array"?

which creates a copy and returns the list and
not the actual array, to make this clear again)
then my statement would make sense, wouldn't it?

in your sub the value is assigned like
$result = (1, 2, 4);
in my sub:

so i shouldn't have said list instead of array;
i meant the list which is created as the
copy of the array.
phooey, i admit i was a little
surprised by your example...

tina