Jump to page: 1 27  
Page
Thread overview
Tuple DIP
Jan 12
Basile B.
Jan 13
Mark
Jan 13
Mark
Jan 13
Chris M.
Jan 13
Nordlöw
Jan 13
Rubn
Jan 13
SrMordred
Jan 13
jmh530
Jan 13
Basile B.
Jan 13
Basile B.
Jan 13
Basile B.
Jan 13
jmh530
Jan 13
Mengu
Jan 13
aberba
Jan 13
rjframe
Jan 13
rjframe
Jan 13
rjframe
Jan 13
Mark
Jan 13
MrSmith
10 hours ago
Atila Neves
5 hours ago
Atila Neves
Re: Tuple DIP - tuple unification with arrays and structs
Jan 16
aliak
Jan 16
jmh530
6 days ago
Timon Gehr
6 days ago
aliak
6 days ago
Timon Gehr
6 days ago
Manu
6 days ago
Timon Gehr
January 12
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
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
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
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
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
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
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
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
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
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
}
« First   ‹ Prev
1 2 3 4 5 6 7