Flag proposal

[Ary Manzana]

On 6/14/11 12:32 PM, Nick Sabalausky wrote:
> "so"<so at so.so>  wrote in message news:op.vw1msqy0mpw3zg at so-pc...
>> On Tue, 14 Jun 2011 04:46:54 +0300, Ary Manzana<ary at esperanto.org.ar>
>> wrote:
>>
>>> On 6/14/11 8:36 AM, so wrote:
>>>> On Mon, 13 Jun 2011 20:19:15 +0300, bearophile<
>>>> <bearophileHUGS at lycos.com>  wrote:
>>>>
>>>>> Andrei:
>>>>>
>>>>>> If we all get convinced that named parameters are worth it,
>>>>>
>>>>> I think this is not going to happen because some people (two?) don't
>>>>> want this feature.
>>>>
>>>> I think they worth it and it is the right time to talk extensively why
>>>> people think they don't.
>>>> And reasoning should not be about its failure or success in another
>>>> language, we better have our own rules.
>>>>
>>>> IMO named arguments in D at least should do:
>>>>
>>>> - Reordering (since we got default parameters, even better)
>>>>
>>>> - It is enabled only if we have access to the function declaration.
>>>>
>>>> - In a function call we either use named arguments for all the
>>>> non-default arguments or call it with the usual syntax. No hybrid stuff,
>>>> no confusion.
>>>
>>> A different rule can be:
>>>    - Named arguments come last.
>>>    - Any previous arguments match the order.
>>
>> IMO the main that makes NAs confusing is allowing hybrid calls.
>> I don't think allowing reordering then introducing two new rules on
>> ordering is a good idea.
>
> I think Ary's suggestion is very simple and easy to understand. Hybrid calls
> are *only* confusing when an unnamed parameter comes after a named one.

Well, that's the way Ruby works :-)

In fact, in Ruby there are no named arguments. So people came up with 
this idea.

def some_function(param_a, param_b, options = {})
   param_c = options['param_c'] || default_for_c
   param_d = options['param_d'] || default_for_d
end

The last argument is a hash (a dictionary) with a default value of an 
empty hash.

So you can call it:

some_function(1, 2)
some_function(1, 2, {'param_c' => 3})
some_function(1, 2, {'param_c' => 3, 'param_d' => 4})

But in Ruby there's a rule: you can skip parenthesis. And you can skip 
the brackets for a hash if it's the last argument. And instead of 
strings symbols are much nicer and efficient. So...

some_function 1, 2
some_function 1, 2, :param_c => 3
some_function 1, 3, :param_c => 3, :param_d => 4

Of course this won't work in D because passing hashes all the time would 
be very inneficcient. But I think positional arguments first, named 
arguments last is a simple rule that's easy to follow and probably 
implement (maybe when I'll go back to my country I'll try to implement it).