Thread overview | |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
|
January 12, 2018 Tuple DIP | ||||
---|---|---|---|---|
| ||||
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 |
January 12, 2018 Re: Tuple DIP | ||||
---|---|---|---|---|
| ||||
Posted in reply to Timon Gehr | 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).
|
January 12, 2018 Re: Tuple DIP | ||||
---|---|---|---|---|
| ||||
Posted in reply to Timon Gehr | 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).)
|
January 12, 2018 Re: Tuple DIP | ||||
---|---|---|---|---|
| ||||
Posted in reply to Timon Gehr | 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.
|
January 13, 2018 Re: Tuple DIP | ||||
---|---|---|---|---|
| ||||
Posted in reply to Timon Gehr | 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)).
|
January 13, 2018 Re: Tuple DIP | ||||
---|---|---|---|---|
| ||||
Posted in reply to Basile B. | 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!
|
January 13, 2018 Re: Tuple DIP | ||||
---|---|---|---|---|
| ||||
Posted in reply to Timon Gehr | 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
|
January 13, 2018 Re: Tuple DIP | ||||
---|---|---|---|---|
| ||||
Posted in reply to Timon Gehr | 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 } |
January 13, 2018 Re: Tuple DIP | ||||
---|---|---|---|---|
| ||||
Posted in reply to Mark | 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); } |
January 13, 2018 Re: Tuple DIP | ||||
---|---|---|---|---|
| ||||
Posted in reply to Timon Gehr | 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
}
|
Copyright © 1999-2021 by the D Language Foundation