Ingo Blechschmidt wrote:
But there is a problem with the ordinary assignment form:

    ($head, @tail) = foo();

If the LHS is an ordinary list (i.e., if we don't use help from the

What is a 'ordinary List' to you? I thought (,) constructs a Lazy list?

then the @tail would get flattened before it reached
the assignment operator. This is turn would cause the statement not to

    my ($head, @tail) = foo();  # is really

    my ($head, @tail);
    ($head, @tail) = foo();     # is really (as @tail is empty)

Aren't you making the silent transition here from the Array type
to the List type? I would argue that the LHS is a Lazy that stores
internal refs to $head and @tail until it is actually iterated.
What I don't know is how lvalue iteration is distinguished from
rvalue iteration.

Then foo is called and the = is dispatched according to the type
of the return value. The outcome hinges on that and on the type
of ($head, @tail) which could be the 2-Tupel (Item,Array) or if
you want 'List of ::X' ::X has to be the LUB of Item and Array,
e.g. Object.

Now assume foo() returns (1,2,3) which is a List of Int. Now
&infix:<=> just iterates the LHS and RHS. LHS is iterated for
lvalues, of course. This results in the three assignments:

  $head    = 1;
  @tail[0] = 2; # lvalue delivered from LHS list
  @tail[1] = 3;

Which is what you expected, or not? For two scalars ($x,$y) = (1,2,3)
the above nicely throws a undef assignment exception:

 $x   = 1;
 $y   = 2;
undef = 3; # iterator ran out of values

    ($head, ())    = foo();     # is really

    ($head)        = foo();     # is really

    $head          = foo();     # !!!

for this I think we need an easier solution... Perhaps flattenning
foo instead of adding a slurp, or making yadda yadda in lvalue throw
it's arguments away silently:

my ($foo, $bar, ...) := foo();

What has become of nullary * for list construction?

my ($foo, $bar, *) := foo();
$TSa.greeting := "HaloO"; # mind the echo!

Reply via email to