On Thursday, 16 July 2015 at 06:32:15 UTC, Jacob Carlborg wrote:
> How about "Bag" or "AliasBag"?

Blob :)

"An object, especially a large one, having no distinct shape or definition"

On Wednesday, 15 July 2015 at 19:52:39 UTC, Jacob Carlborg wrote:
> On 2015-07-15 18:09, "Marc =?UTF-8?B?U2Now7x0eiI=?= <schuetzm@gmx.net>" wrote:
>
>> Yeah, "splat" as a name for an auto-expanding thingy would be a novelty.
>> Ruby for instance doesn't have anything like that, it has a splat
>> _operator_ (asterisk) to expand a normal array, or conversely, capture
>> several arguments in one parameter.
>
> I'm not sure what should count as auto-expanding, but this works in Ruby:
>
> a, b = [1, 2]
>
> No extra operator is required in this case.

What I meant is that there is no equivalent to the behaviour of TypeTuples:

    assert(is(TypeTuple!(int, float, TypeTuple!(string, int)) ==
              TypeTuple!(int, float, string, int));
    TypeTuple!(int, int) a;
    a[0] = 1; a[1] = 2;
    void foo(int, int);
    foo(a); // works

But not in Ruby:

    [1, 2, [3, 4]] != [1, 2, 3, 4]
    def foo a, b ; end
    foo([1, 2]);  // doesn't work
    foo(*[1, 2]); // but works with splat operator

Maybe auto-flattening is a better name for this behaviour?

My point is that there is no type in Ruby that is inherently "splatty", rather it's the operator that produces this behaviour. Therefore, "splat" is not used as a noun to signify such a type.

On Wednesday, 15 July 2015 at 21:44:37 UTC, Timon Gehr wrote:
> It should instead be acknowledged that there /should/ be no difference in what three things can be passed to X(T...) and X(alias a, alias b, alias c). The X(T...) if(T.length==k) pattern is ridiculous.

Yes, that would immediately solve the objection against "Alias" in the name, beside making the language more consistent.

On Thursday, 16 July 2015 at 05:51:01 UTC, Mike wrote:
> On Thursday, 16 July 2015 at 05:44:29 UTC, Ola Fosheim Grøstad wrote:
>
>>
>> C++ also have related use of the word "pack":
>>
>> http://en.cppreference.com/w/cpp/language/parameter_pack
>>
>
> Nice!  From the description:
>
> "A template parameter pack is a template parameter that accepts zero or more template arguments (non-types, types, or templates). A function parameter pack is a function parameter that accepts zero or more function arguments.
>
> A template with at least one parameter pack is called a variadic template."
>
> Sound familiar?  I propose simply "Pack".
>

Only that it is in fact an UnPack...

On Thursday, 16 July 2015 at 07:30:19 UTC, Mike wrote:
> I know Ola is making light of this situation and many of you find this discussion beneath you, but we need a name, and with the release looming we need it relatively soon.

Naming is difficult, but "list" and "pack" (alluding to unpacking) are the most accurate terms.

But you need a general term that covers both types and values/expressions... I don't know of one. "alias" is not an abstraction but more like an action that binds something. Maybe something like "mixed"…

Just "Pack" would be confusing... Sounds like a verb and I wouldn't understand it without looking it up in the docs. You need a word before "pack".

These I would be able to infer from context:

"MixedList"
"CompileTimeList"
"CTList"
"AliasList"
"AliasPack"
"ParamPack"
"ArgPack"
"Parameters"
"Arguments"

> Given that that D has its roots in C++ and this construct is similar to the one in question, it seems like a good fit.

Yes, if C++ integration is going to big thing for D, it sounds reasonable to use similar terminology. Searching on cppreference.com is useful.

On Thursday, 16 July 2015 at 08:00:43 UTC, Marc Schütz wrote:
> My point is that there is no type in Ruby that is inherently "splatty", rather it's the operator that produces this behaviour. Therefore, "splat" is not used as a noun to signify such a type.

Yes, please forget about the tongue-in-cheek slang-term "splat".  That's for kids!

"splat" is just slang for "asterisk"-something:

https://en.wikipedia.org/wiki/Asterisk

«In Commodore (and related) filesystems, an asterisk appearing next to a filename in a directory listing denotes an improperly closed file, commonly called a "splat file."»

«Certain categories of character types in role-playing games are called splats, and the game supplements describing them are called splatbooks. This usage originated with the shorthand "*book" for this type of supplement[…]»

«In many MUDs and MOOs, as well as "male", "female", and other more esoteric genders, there is a gender called "splat", which uses an asterisk to replace the letters that differ in standard English gender pronouns. For example, h* is used rather than him or her.»

You might as well call it "AliasGoo".

On Thursday, 16 July 2015 at 05:51:01 UTC, Mike wrote:

> "A template parameter pack is a template parameter that accepts zero or more template arguments (non-types, types, or templates). A function parameter pack is a function parameter that accepts zero or more function arguments.
>
> A template with at least one parameter pack is called a variadic template."
>
> Sound familiar?  I propose simply "Pack".

+ 1

On Wednesday, 15 July 2015 at 21:44:37 UTC, Timon Gehr wrote:
> It should instead be acknowledged that there /should/ be no difference in what three things can be passed to X(T...) and X(alias a, alias b, alias c). The X(T...) if(T.length==k) pattern is ridiculous.

+1

On 2015-07-16 10:00, "Marc =?UTF-8?B?U2Now7x0eiI=?= <schuetzm@gmx.net>" wrote:

> What I meant is that there is no equivalent to the behaviour of TypeTuples:
>
>      assert(is(TypeTuple!(int, float, TypeTuple!(string, int)) ==
>                TypeTuple!(int, float, string, int));
>      TypeTuple!(int, int) a;
>      a[0] = 1; a[1] = 2;
>      void foo(int, int);
>      foo(a); // works
>
> But not in Ruby:
>
>      [1, 2, [3, 4]] != [1, 2, 3, 4]
>      def foo a, b ; end
>      foo([1, 2]);  // doesn't work
>      foo(*[1, 2]); // but works with splat operator
>
> Maybe auto-flattening is a better name for this behaviour?
>
> My point is that there is no type in Ruby that is inherently "splatty",
> rather it's the operator that produces this behaviour. Therefore,
> "splat" is not used as a noun to signify such a type.

I see what you mean now.

-- 
/Jacob Carlborg

On Thursday, 16 July 2015 at 08:00:43 UTC, Marc Schütz wrote:
> Maybe auto-flattening is a better name for this behaviour?

"flattening": concatenating all the children recursively.

"argument unpacking"/"expansion": filling in the actual parameters

Anyway, auto-flattening is undesirable as it makes the language more weakly typed and hides what goes on. And it gets in the way for structural pattern matching. But those issues are off-topic, I guess.