Stuart Cook wrote:
> On 11/10/05, Austin Hastings <[EMAIL PROTECTED]> wrote:
>>                                              A rule that says
>>                                              "splatting
>> a list coerces all pairs into named args" works just fine. The
>> corresponding rule, "accessing the parameters to your sub as a list
>> (not using *%args) coerces all named args to pairs". Presto!
>> Reversible, etc.
> 2)
> What if the list contains pairs, but you want to pass them as
> positionals? What if it might contain pairs, but you're not sure?
> What if you introduce a new named parameter (or change a parameter
> name), and what you thought was a positional pair now becomes a named
> arg?
> Your suggestion would involve re-introducing some of the 'magic' that
> real experience suggests we should be trying desperately to get away
> from.

Exactly. I'd like to add that, under the proposal, you always know what
things are passed how, only by looking for a "*".

    foo $var;    # always positionally, even if $var isa Pair
    foo *$pair;  # always named

    foo [EMAIL PROTECTED];  # always positionally
    foo *%hash;   # always named (hash keys taken as parameter names)

Previously, you wasn't able to know whether you passed something
positionally or by name:

    sub bar ($x) { grtz $x }
    bar 42;       # 42 passed to &grtz positionally
    bar a => 42;  # either the pair (a => 42) passed to &grtz
                  # positionally or the number 42 passed by name

Under the new proposal, "grtz $x" always passes $x positionally. You
don't need &grtz's signature, nor do you need to know $x's type (is $x
a Pair?). Compare this with the old semantics:

  grtz $x;
  # $x is not a Pair? ==> $x passed positionally
  # else ==>
  #   &grtz expects a Pair as its first positional parameter?
  #     ==> $x passed positionally
  #   else ==>
  #     &grtz's signature lists a parameter named $x.key?
  #        ==> $x.value passed by name
  #     else
  #       ==> $x passed positionally

> And look, if you really wanted to, you could define your own
> splat-style operator that works exactly as you describe.  But I don't
> think it should be the default.

Right. Under the proposal, you can -- *if you want to* -- use pairs
stuffed in arrays as named arguments:

    foo *hash(@array_of_pairs);
      # @array_of_pairs's pairs used as named args

      # @array_of_pairs's pairs used positionally

But if we made [EMAIL PROTECTED] mean that...

* [EMAIL PROTECTED]'s pairs are always taken as named arguments,
  there wouldn't be a simple way to pass pairs positionally.

* [EMAIL PROTECTED]'s pairs are always taken as pairs,
  there wouldn't be a simple way to use the pairs as named arguments.

* [EMAIL PROTECTED]'s pairs are taken as pairs or named arguments,
  depending on the called subroutine (does it accept named params?
  Do some parameters specifically want a Pair? etc.), we'd introduce
  non-local non-determinism to a quite important part of the language.


Reply via email to