Also
function f(args: x, y, z) {
will suggest to TypeScript readers that the parameter "args" has type "x".
On Sun, Nov 10, 2013 at 11:44 AM, Mark S. Miller <[email protected]> wrote:
> Hi Brendan and Allen, you are both responding only to my point #1. I
> consider my point #2 --- cognitive load of the reader on encountering a
> rarely seen construct --- to be the more significant criticism here.
>
> On these grounds, your
>
> function f(args: x, y, z) {
>
> is worse. Given how ":" is already used in JS, this suggests that "args"
> is either a label name, which the more astute reader can easily disqualify,
> or a property name, suggesting some shorthand for named parameters.
>
> Note that I am not saying that the meanings of all syntactic constructs
> have to be guessable with no guidance. But the rarely used ones do.
>
> 3) Awkward syntax for some rarely used cases is the price of good syntax
> for common cases.
>
>
>
>
> On Sun, Nov 10, 2013 at 11:08 AM, Brendan Eich <[email protected]>wrote:
>
>> On the other hand, we are this close in ES6 to relieveing people from
>> having to use arguments at all.
>>
>> I like the intention behind Allen's idea. To defend the concrete syntax a
>> bit, one would argue that only the final formal parameter may be prefixed
>> with #, and we are free to use # in other ways elsewhere.
>>
>> If # should be kept reserved even in this context, then perhaps something
>> like
>>
>> function f(args: x, y, z) {
>> // use x, y, z freely (they could be patterns)
>> switch (args.length) {
>> case 1: ...
>> case 2: ...
>> // etc.
>> }
>> }
>>
>> The "label" names a rest parameter for the entire parameter list.
>>
>> /be
>>
>>> Mark S. Miller <mailto:[email protected]>
>>> November 10, 2013 6:52 PM
>>>
>>> 1) "#" is one of the few ascii characters we haven't used up yet. Let's
>>> not use it up on a minor convenience.
>>>
>>> 2) Introducing new syntax for use cases that are expected to be
>>> frequent, e.g., classes, often pays for its weight. The frequency makes it
>>> likely that readers will understand what it is the vast majority of times
>>> they encounter it. New syntax that gets used once in a blue moon can only
>>> be justified if the pain of doing without in those blue-moon cases is huge.
>>> In this case, it isn't. For those rare occasions when they see it, readers
>>> are much more likely to guess what "arguments.length" mean that this funny
>>> newfangled "#" thing.
>>>
>>> Code is read much more often than it is written -- at least code that
>>> matters. Brevity is useful as a metric only to the degree that it serves as
>>> a proxy for cognitive load on the reader.
>>>
>>>
>>>
>>>
>>>
>>>
>>> --
>>> Cheers,
>>> --MarkM
>>>
>>> _______________________________________________
>>> es-discuss mailing list
>>> [email protected]
>>> https://mail.mozilla.org/listinfo/es-discuss
>>> Allen Wirfs-Brock <mailto:[email protected]>
>>> November 10, 2013 7:12 PM
>>>
>>> One of the the few remaining uses of a function's 'arguments' binding is
>>> to determine the actual number of passed arguments. This is necessary in
>>> some overloading scenarios where a function has different behavior when an
>>> argument is completely absent then it has when undefined (or any other
>>> default value) is explicitly passed in that parameter position. That
>>> situation occurs in a number of DOM APIs and even a few ES library
>>> functions.
>>>
>>> For example(see https://bugs.ecmascript.org/show_bug.cgi?id=1877 ),
>>> Array.prototype.splice returns different results for:
>>> [1,2,3].splice()
>>> and
>>> [1,2,3].splice(undefined)
>>>
>>> The natural ES6 declaration for a splice function is:
>>>
>>> function splice(start, deleteCount, ...items) {...
>>>
>>> but if you write it this way then within the body you have to have a
>>> test like:
>>>
>>> if (arguments.length == 0) {...
>>>
>>> to implement the correct web-compatable behavior.
>>>
>>> Or, alternatively you could declare the functions as:
>>>
>>> function splice(...actualArgs) {
>>> let [start, stop, ...item] = actualArgs;
>>> ...
>>> if (actualArgs.length == 0) {...
>>>
>>> So, to implement a Web-compaable version of splice you either have to
>>> use 'arguments' to determine the actual number of passed objects or you
>>> need to declare it with a bogus parameter pattern and use explicit or
>>> implicit destructuring to parse out the positional parameters.
>>>
>>> One way around this dilemma would be to provide a syntactic affordance
>>> for determing the actual argument count. For example, one possibility
>>> would be to allow the last item of any formal parameter list to be an item
>>> of the syntactic form:
>>>
>>> ActualArgumentCount : '#' BindingIdentifier
>>>
>>> So, the declaration for splice could then be:
>>>
>>> function splice(start, deleteCount, ...items, #argCount) {
>>> ...
>>> if (argCount == 0) {...
>>>
>>> Thoughts?
>>>
>>> Allen
>>>
>>>
>>> _______________________________________________
>>> es-discuss mailing list
>>> [email protected]
>>> https://mail.mozilla.org/listinfo/es-discuss
>>>
>>
>
>
> --
> Cheers,
> --MarkM
>
--
Cheers,
--MarkM
_______________________________________________
es-discuss mailing list
[email protected]
https://mail.mozilla.org/listinfo/es-discuss
