For Perl,

$aref = [ 'a', 'b' ];
$href = { 'foo' => 123 };
[download]

$aref = do { my @a = ('a', 'b'); \@ };
$href = do { my %h = ('foo' => 123); \%h };
[download]

So, a better name for them would be "anonymous hash ref" and "anonymous array ref", IMO.

And no, there are no implicit names. Perl doesn't use the names internally. It doesn't need them.

And perhaps you could look into typeglobs and stashes (Symbol Table hASHES), you might find it interesting. (Best discussion I found is in the old, 1st edition of the O'Reilly book "Advanced Perl Programming"; the second edition is a different book.)

Named        Anonymous
@array       []
%hash        {}
[download]

If you say somewhere in your code

@array;
[download]

the named array @array is created, and it's there, you can use it later to stuff things in. Whereas if you say

[];
[download]

you create an anonymous array, and on the next line it's gone. Why? The creation of an anonymous array returns a pointer to where that array is allocated. If you don't store that pointer somewhere, it's gone, and the anonymous array too. If you create a named array, the array is "contained in the name", for anonymous arrays you have to store its location somewhere:

$arrayref = [];
[download]

Now you have the reference to that anonymous array in you scalar variable $arrayref, and you can pass this pointer around, or fill the anonymous array pointed at by dereferencing it:

$ary = $arrayref;
push @$ary,"foo";
print $arrayref->[0]; # prints "foo" \
print @$arrayref[0];  # prints "foo" - same pointer value in $ary and 
+$arrayref
print $ary->[0];      # prints "foo" /
[download]

So a named array has a name, which is the word after the sigil '@', while an anonymous array only has a location somewhere in perl's memory.

we all knew that the implicit variable here is $_ that is being printed out.

This "implicit variable" has nothing to do with an array, but with the for iterator. You can use that with literals too:

for("foo") {
    print;     # prints foo
    undef $_;  # dies with "Modification of a read-only value attempte
+d"
               # - literals cannot be modified
}
[download]

The variable $_ is not attached to an array, it just happens to be the global default variable a.k.a The Thing (which in a for loop is aliased, so for works with its own version and doesn't stomp on other operator's idea of what $_ is).

so in connection with creating anonymous data structures below:

my $ref = ["my","list"];
[download]

what would be that implicit name (variable) that was created? and how can i access it?

There is no implicit name - all there is is a pointer. If you force that pointer to be a string (e.g. by saying print $ref), perl translates the pointer into something readable (e.g. ARRAY(0x8166c28)).

All you have is a scalar variable $ref, to which you assigned the pointer to an anonymous array. You have to dereference that address pointer if you want to loop over the anonymous array - the loop body is exactly the same:

for (@$ref) {
    print;
    $_ = undef;
}
# the [] array pointed to with the content of $ref is now [undef,undef
+]
[download]

See perlref for further information.

_($_=" "x(1<<5)."?\n".q·/)Oo.  G°\        /
                              /\_¯/(q    /
----------------------------  \__(m.====·.(_("always off the crowd"))."·
");sub _{s./.($e="'Itrs `mnsgdq Gdbj O`qkdq")=~y/"-y/#-z/;$e.e && print}

I had to look up anonymous data structures to figure out what you were referring to and it appears that they are just talking about references. THAT I can help you with.

Normally there are two ways of working with a variable, making a copy of it, or using a reference to it. A simplified example would be a sign-in sheet for a writing class. You want everyone to write their name on the sheet so you have to get information from everyone. There are two ways of doing this,

• Make a copy of it.
  1. make a copy of the sign-in sheet.
  2. have the student sign the sheet new copy.
  3. Get the copy back from the student.
  4. Throw away the old sign-in sheet and go back to step 1. Repeat until finished
• Use a reference
1. Take a sign-in sheet.
2. Have the student sign their new on the sign-in sheet
3. Repeat until finished.

The first way sounds stupid, but you will be surprised how often it occurs, especially with beginners. Here is code to show how it works.

#!/usr/bin/perl

use strict;
use warnings;

# Make a copy of a variable

my $counter = 0;
print "Copying and replacing the variable\n";
for (1..10) {
    $counter = increment_number( $counter );
    print "Count is $counter\n";
}

$counter = 0;
print "Passing a reference to the variable\n";
for (1..10) {
    increment_number( \$counter );
    print "Count is $counter\n";
}

sub increment_number {
    my $number = shift;

    if (ref $number eq 'SCALAR') {
        $$number++;
        return;
    }
    return ++$number;
}
[download]

Hi Herkum, So colour me a noob, but what you are saying is in your first example we are chewing up memory creating a copy of $counter. Whereas in the second example we are pointing to the original. The implication being that example two is more efficient/faster/leet? Is that right. Lance

Kia Kaha, Kia Toa, Kia Manawanui!
Be Strong, Be Brave, Be perservering!

your first example we are chewing up memory creating a copy of $counter

Correct.

in the second example we are pointing to the original. The implication being that example two is more efficient/faster/leet? Is that right.

Correct as well. The example I used does not really offer any performance benefits because it is too small.

Lets supposed you have a million element array. In the first example you would, create 2 copies of that million element array in your program(So it takes more memory). You would also be passing million values to and from the function(so it would be slower).

If you use a reference you have one copy of that array. You only passing a single value to the function. This can be provide enormous performances benefits when working with a large amount of data.

There are times you want to make a copy because you don't want to change the original data. But if you are modifying the original values you should use references.

my $hashref  = { A => 1, B => 2 };
my $arrayref = [ 1, 2, 3 ];
[download]

You would then access the elements of the references using ->:

print $hashref->{B}; # 2
print $arrayref->[2]; # 3
[download]

or by

print %$hashref{B}; # 2
print @$arrayref[2]; # 3
[download]

I much prefer ->, for what it's worth

I much prefer ->, for what it's worth

As a general rule, /me too. Though as with most things, there are situations in which it is best suited and situations in which the other way is preferable. Also, they're not equivalent in all respects.

Does it really have to be a ref to be anonymous though? The most common use of anonymous arrays and hashes for me is in return values for subs:

sub foo{
    return { bar => 'baz' };
}
[download]

You could just as easily return an anonymous hash:

sub foo{
    return ( bar => 'baz' );
}
[download]

The other common place to see anonymous hash and array refs (always refs in this case) is in constuction of multi-dimentional data structures:

my $foo = [
    { bar => 'baz' },
];
[download]

So the arrayref isn't anonymous, but the hashref that is the first (and only element) is.

perl -e 'split//,q{john hurl, pest caretaker}and(map{print @_[$_]}(joi
+n(q{},map{sprintf(qq{%010u},$_)}(2**2*307*4993,5*101*641*5261,7*59*79
+*36997,13*17*71*45131,3**2*67*89*167*181))=~/\d{2}/g));'
[download]

You could just as easily return an anonymous hash:

sub foo{
    return ( bar => 'baz' );
}
[download]

That is not a hash, but a list (in fact all subs only return lists) suitable for being assigned to a hash, period.

Fair enough. My point was simply that it needn't be a reference to be an anonymous data structure.

perl -e 'split//,q{john hurl, pest caretaker}and(map{print @_[$_]}(joi
+n(q{},map{sprintf(qq{%010u},$_)}(2**2*307*4993,5*101*641*5261,7*59*79
+*36997,13*17*71*45131,3**2*67*89*167*181))=~/\d{2}/g));'
[download]