As promised [1], I have started setting up a DIP to improve tuple ergonomics in D:

https://github.com/tgehr/DIPs/blob/tuple-syntax/DIPs/DIP1xxx-tg.md


This DIP aims to make code like the following valid D:

---
auto (a, b) = (1, 2);
(int a, int b) = (1, 2);
---

---
foreach((sum, diff); [(1, 2), (4, 3)].map!((a, b) => (a + b, a - b)))
{
    writeln(sum, " ", diff);
}
/+ prints:
3 -1
7 1
+/
---

Before going ahead with it, I'd like some preliminary community input:

- I'm not yet completely satisfied with the DIP.
  (See section "Limitations".)
  Please let me know suggestions or further concerns you might have.


- There are good example use cases missing. While I'm confident I could
  invent a few of them given a little time, I thought maybe I can
  expedite the process and make the point more convincingly by asking
  for use cases you encountered in your own code. The DIP already
  contains an example due to bearophile.


[1] https://forum.dlang.org/post/or625h$2hns$1@digitalmars.com

On 12.01.2018 23:44, Timon Gehr wrote:
> ...
> 
> Before going ahead with it, I'd like some preliminary community input:
> ...
Also, if you have more links to forum posts requesting related features, that would be useful (googling turned up the ones that are in the DIP, but I know that there were more).

On 12.01.2018 23:44, Timon Gehr wrote:
> 
> ---
> auto (a, b) = (1, 2);
> (int a, int b) = (1, 2);
> ---

(The two lines are two independent examples :o).)

On Friday, 12 January 2018 at 22:44:48 UTC, Timon Gehr wrote:
> As promised [1], I have started setting up a DIP to improve tuple ergonomics in D:
>
> https://github.com/tgehr/DIPs/blob/tuple-syntax/DIPs/DIP1xxx-tg.md

markdown trick: you can use


```diff
```

for a nicer grammar section.

On Friday, 12 January 2018 at 22:44:48 UTC, Timon Gehr wrote:
> As promised [1], I have started setting up a DIP to improve tuple ergonomics in D:
>
> https://github.com/tgehr/DIPs/blob/tuple-syntax/DIPs/DIP1xxx-tg.md
>
>
> This DIP aims to make code like the following valid D:
>
> ---
> auto (a, b) = (1, 2);
> (int a, int b) = (1, 2);
> ---
>
> ---
> foreach((sum, diff); [(1, 2), (4, 3)].map!((a, b) => (a + b, a - b)))
> {
>     writeln(sum, " ", diff);
> }
> /+ prints:
> 3 -1
> 7 1
> +/
> ---
>
> Before going ahead with it, I'd like some preliminary community input:
>
> - I'm not yet completely satisfied with the DIP.
>   (See section "Limitations".)
>   Please let me know suggestions or further concerns you might have.
>
>
> - There are good example use cases missing. While I'm confident I could
>   invent a few of them given a little time, I thought maybe I can
>   expedite the process and make the point more convincingly by asking
>   for use cases you encountered in your own code. The DIP already
>   contains an example due to bearophile.
>
>
> [1] https://forum.dlang.org/post/or625h$2hns$1@digitalmars.com

Could we also support function tuples? For instance:

int sum(int a, int b) { return a+b; }
int diff(int a, int b) { return a-b; }

(int, int) f = (sum, diff) // no ";" for consistency with existing syntax
int (x,y) = f(1, 2); // x=3, y=-1
int (w,z) = (1, 2).f() // same as above, UFCS
int (u,v) = (1, 2).(sum, diff) // same as above, "lambda tuple"

In the last example, (sum, diff) is basically lowered to (x,y) => (sum(x,y), diff(x,y)).

On 13.01.2018 00:16, Basile B. wrote:
> On Friday, 12 January 2018 at 22:44:48 UTC, Timon Gehr wrote:
>> As promised [1], I have started setting up a DIP to improve tuple ergonomics in D:
>>
>> https://github.com/tgehr/DIPs/blob/tuple-syntax/DIPs/DIP1xxx-tg.md
> 
> markdown trick: you can use
> 
> 
> ```diff
> ```
> 
> for a nicer grammar section.

Updated, thanks!

On Friday, 12 January 2018 at 22:44:48 UTC, Timon Gehr wrote:
> As promised [1], I have started setting up a DIP to improve tuple ergonomics in D:
>
> [...]

Yes please

Should include an example of returning a tuple from a function. I know one of the pains with variadic templates is that they can't be returned.

So maybe something that goes over the following use case:


auto returnTuple(Args...)(Args args)
{
    return args;
}


(int a, float b) = returnTuple(4, 1.0f);


Or just returning your regular tuple:


(int, float) returnSomeTuple()
{
    return (10, 1.0f); // or whatever
}

On 13.01.2018 01:20, Mark wrote:
> 
> Could we also support function tuples?

In principle, yes, though I imagine it is a lot harder to argue for its inclusion than for that of the features currently proposed in the DIP, because existing language features already come rather close.

> For instance:
> 
> int sum(int a, int b) { return a+b; }
> int diff(int a, int b) { return a-b; }
> 
> (int, int) f = (sum, diff) // no ";" for consistency with existing syntax

No ";" is inconsistent. Also the type of f cannot be (int, int), and (sum, diff) would try to call sum and diff with 0 arguments and fail.

> int (x,y) = f(1, 2); // x=3, y=-1
> int (w,z) = (1, 2).f() // same as above, UFCS
> int (u,v) = (1, 2).(sum, diff) // same as above, "lambda tuple"
> 
> In the last example, (sum, diff) is basically lowered to (x,y) => (sum(x,y), diff(x,y)).

I think this is easy enough to achieve without dedicated syntax:

import std.typecons;

template apply(F...){
    auto apply(T)(T arg){
        import std.conv, std.range, std.algorithm;
        return mixin(text("(",iota(F.length).map!(i=>text("F[",i,"](arg)")).join(","),")"));
    }
}

void main(){
    int sum(int a, int b) { return a+b; }
    int diff(int a, int b) { return a-b; }
    auto (u,v)=(1,2).apply!(sum, diff);
    import std.stdio;
    writeln(u," ",v);
}

On 12/01/2018 10:44 PM, Timon Gehr wrote:
> As promised [1], I have started setting up a DIP to improve tuple ergonomics in D:
> 
> https://github.com/tgehr/DIPs/blob/tuple-syntax/DIPs/DIP1xxx-tg.md
> 
> 
> This DIP aims to make code like the following valid D:
> 
> ---
> auto (a, b) = (1, 2);
> (int a, int b) = (1, 2);
> ---
> 
> ---
> foreach((sum, diff); [(1, 2), (4, 3)].map!((a, b) => (a + b, a - b)))
> {
>      writeln(sum, " ", diff);
> }
> /+ prints:
> 3 -1
> 7 1
> +/
> ---
> 
> Before going ahead with it, I'd like some preliminary community input:
> 
> - I'm not yet completely satisfied with the DIP.
>    (See section "Limitations".)
>    Please let me know suggestions or further concerns you might have.
> 
> 
> - There are good example use cases missing. While I'm confident I could
>    invent a few of them given a little time, I thought maybe I can
>    expedite the process and make the point more convincingly by asking
>    for use cases you encountered in your own code. The DIP already
>    contains an example due to bearophile.
> 
> 
> [1] https://forum.dlang.org/post/or625h$2hns$1@digitalmars.com

I really dislike the syntax, it looks hard to parse.

#{int, string}

Where T... all equal types

#{1, "str"}

Where T... all equal values
Alternatively:

#(1, "str")

Since it is "arguments" to "construct" it.
Doesn't that look easier to parse and use?


It can be just a bit of syntax suger around (in object.di):

struct Tuple(T...) {
	alias Types = T;

	T args;

	// opIndex/opIndexAssign
}