There are quite a few tests in the spectest suite that
make mention of "arrayref" and "hashref", and that expect
things to work like references do in Perl 5.  I'd like to
get some confirmation/clarification on them.

Here's one example:

    my $foo = [ 42 ];
    my $bar = { a => 23 };
    $foo[1] = $bar;
    $bar<b> = 24;

    say $foo[1]<b>;     #  "24" or undef ???

The test suite expects "24" to be output here, treating
treating C< $foo[1] > as a reference to the hash in
C<$bar>, such that any changes to C<$bar> are also reflected
in C<$foo[1]>.  Is this correct Perl 6?  I would somewhat expect
a reference to be instead handled using a statement like

    $foo[1] := $bar;

Comments and clarifications appreciated.

Pm

IMHO yes. Remember that $foo is really just an Array object, just like
any other object. Why should Array objects be cloned on assignment? If
you do a
@a = @b
you get cloning behaviour because the @ sigil implies a container type,
whereas a with a $ sigil you just hand references to objects.

--
Moritz Lenz
http://moritz.faui2k3.org/ |  http://perl-6.de/

On Monday, 18. August 2008 20:38:05 Patrick R. Michaud wrote:

I would also opt for copy semantics whenever = is used
for assignment. But it seems to be the case that this
is not deep, just like captures are only one level deep
readonly. So, I would also expect $foo[1] = \$bar to
result in 24.

Regards, TSa.
--
"The unavoidable price of reliability is simplicity" -- C.A.R. Hoare
"Simplicity does not precede complexity, but follows it." -- A.J. Perlis
1 + 2 + 3 + 4 + ... = -1/12  -- Srinivasa Ramanujan

: There are quite a few tests in the spectest suite that
: make mention of "arrayref" and "hashref", and that expect
: things to work like references do in Perl 5.  I'd like to
: get some confirmation/clarification on them.
:
: Here's one example:
:
:     my $foo = [ 42 ];
:     my $bar = { a => 23 };
:     $foo[1] = $bar;
:     $bar<b> = 24;
:
:     say $foo[1]<b>;     #  "24" or undef ???
:
: The test suite expects "24" to be output here, treating
: treating C< $foo[1] > as a reference to the hash in
: C<$bar>, such that any changes to C<$bar> are also reflected
: in C<$foo[1]>.  Is this correct Perl 6?  I would somewhat expect
: a reference to be instead handled using a statement like
:
:     $foo[1] := $bar;
:
: Comments and clarifications appreciated.

Well, sure, you can use := for clarity, but we left = in the language
to provide (to the extent possible) the same semantics that it
does in Perl 5.  And when it comes to non-value types, there really
are still references, even if we try not to talk about them much.
So I think assignment is basically about copying around identities,
where value types treat identity differently than object types (or
at least, objects types that aren't pretending to be value types).
In any case, an array or a hash is not pretending to be a value type,
so it just clones its identity (a reference, if you will) by default.

It's quite possible this is insane, but I can't tell in my current
state of jet lag.

Larry

But C<$foo[1] = $bar> *does* use copy semantics. The thing on the right
is a reference to a hash, and that reference is copied (by value) into
C<$foo[1]>.

It seems what you're really requesting is for the assignment operator to
auto-dereference references. But if you can't copy references, they
become pretty useless.
=thom