www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - Unofficial wish list status.(Nov 2008)

reply 4tuu4k002 sneakemail.com writes:
Hi

This is the monthly status for the unofficial d wish list: 
http://all-technology.com/eigenpolls/dwishlist/

Right now the wish list looks like this:
Oct 31 2008
next sibling parent reply ore-sama <spam here.lot> writes:
4tuu4k002 sneakemail.com Wrote:



 int, int getPoint();
 int a,b;
 a,b = getPoint();


Provided we have lvalue array literals, this can fit to general array
operations rules:
int[] getPoint();
int a,b;
[a,b]=getPoint();
Nov 01 2008
parent reply KennyTM~ <kennytm gmail.com> writes:
ore-sama wrote:

 4tuu4k002 sneakemail.com Wrote:
 


 int, int getPoint();
 int a,b;
 a,b = getPoint();


 
 Provided we have lvalue array literals, this can fit to general array
operations rules:
 int[] getPoint();
 int a,b;
 [a,b]=getPoint();


int code;
string msg;

[code, msg] = getError();
Nov 01 2008
next sibling parent reply "Denis Koroskin" <2korden gmail.com> writes:
On Sat, 01 Nov 2008 15:00:01 +0300, KennyTM~ <kennytm gmail.com> wrote:


 ore-sama wrote:

 4tuu4k002 sneakemail.com Wrote:



 int, int getPoint();
 int a,b;
 a,b = getPoint();


  Provided we have lvalue array literals, this can fit to general array  
 operations rules:
 int[] getPoint();
 int a,b;
 [a,b]=getPoint();


 int code;
 string msg;

 [code, msg] = getError();


This is now a tuple, its type is (int,string):
(code, msg) = getError(); // more consistent, but less appealing
Nov 01 2008
parent KennyTM~ <kennytm gmail.com> writes:
Denis Koroskin wrote:

 On Sat, 01 Nov 2008 15:00:01 +0300, KennyTM~ <kennytm gmail.com> wrote:
 

 ore-sama wrote:

 4tuu4k002 sneakemail.com Wrote:



 int, int getPoint();
 int a,b;
 a,b = getPoint();


  Provided we have lvalue array literals, this can fit to general 
 array operations rules:
 int[] getPoint();
 int a,b;
 [a,b]=getPoint();


 int code;
 string msg;

 [code, msg] = getError();


 
 This is now a tuple, its type is (int,string):
 (code, msg) = getError(); // more consistent, but less appealing


Right. It should be a tuple instead of an array for more generic variants.

I think this (x, y) = ... is just as good as [x, y] = ...
Nov 01 2008
prev sibling next sibling parent ore-sama <spam here.lot> writes:
KennyTM~ Wrote:


 int code;
 string msg;
 
 [code, msg] = getError();


Uh... I thought about arrays. For this we need lvalue struct literals.
Nov 01 2008
prev sibling parent reply Andrei Alexandrescu <SeeWebsiteForEmail erdani.org> writes:
KennyTM~ wrote:

 ore-sama wrote:

 4tuu4k002 sneakemail.com Wrote:



 int, int getPoint();
 int a,b;
 a,b = getPoint();


 Provided we have lvalue array literals, this can fit to general array 
 operations rules:
 int[] getPoint();
 int a,b;
 [a,b]=getPoint();


 
 int code;
 string msg;
 
 [code, msg] = getError();


Tuple!(int, "code", string, "msg") getError();
auto e = getError;


Andrei
Nov 01 2008
parent reply "Denis Koroskin" <2korden gmail.com> writes:
On Sat, 01 Nov 2008 19:04:16 +0300, Andrei Alexandrescu  
<SeeWebsiteForEmail erdani.org> wrote:


 KennyTM~ wrote:

 ore-sama wrote:

 4tuu4k002 sneakemail.com Wrote:



 int, int getPoint();
 int a,b;
 a,b = getPoint();


 Provided we have lvalue array literals, this can fit to general array  
 operations rules:
 int[] getPoint();
 int a,b;
 [a,b]=getPoint();


  int code;
 string msg;
  [code, msg] = getError();


 Tuple!(int, "code", string, "msg") getError();
 auto e = getError;


 Andrei


Imagine 'code' and 'msg' are already there as local variables and you want  
to reuse them. How should you do this?
Nov 01 2008
parent reply Andrei Alexandrescu <SeeWebsiteForEmail erdani.org> writes:
Denis Koroskin wrote:

 On Sat, 01 Nov 2008 19:04:16 +0300, Andrei Alexandrescu 
 <SeeWebsiteForEmail erdani.org> wrote:
 

 KennyTM~ wrote:

 ore-sama wrote:

 4tuu4k002 sneakemail.com Wrote:



 int, int getPoint();
 int a,b;
 a,b = getPoint();


 Provided we have lvalue array literals, this can fit to general 
 array operations rules:
 int[] getPoint();
 int a,b;
 [a,b]=getPoint();


  int code;
 string msg;
  [code, msg] = getError();


 Tuple!(int, "code", string, "msg") getError();
 auto e = getError;


 Andrei


 
 Imagine 'code' and 'msg' are already there as local variables and you 
 want to reuse them. How should you do this?


I've been thinking of defining a simple function that binds to variable 
addresses and allows assignment from a tuple, in which case the code 
would be:

group(&code, &msg) = getError;

In "the future" we'll have variadic ref arguments, in which case the 
"&"s can be dropped:

group(code, msg) = getError;

Also in "the future" variable definitions will be expressions, in which 
case the code to define and assign code and msg becomes:

group(int code, string msg) = getError;


Andrei
Nov 01 2008
next sibling parent reply "Denis Koroskin" <2korden gmail.com> writes:
On Sat, 01 Nov 2008 19:33:01 +0300, Andrei Alexandrescu  
<SeeWebsiteForEmail erdani.org> wrote:


 Denis Koroskin wrote:

 On Sat, 01 Nov 2008 19:04:16 +0300, Andrei Alexandrescu  
 <SeeWebsiteForEmail erdani.org> wrote:


 KennyTM~ wrote:

 ore-sama wrote:

 4tuu4k002 sneakemail.com Wrote:



 int, int getPoint();
 int a,b;
 a,b = getPoint();


 Provided we have lvalue array literals, this can fit to general  
 array operations rules:
 int[] getPoint();
 int a,b;
 [a,b]=getPoint();


  int code;
 string msg;
  [code, msg] = getError();


 Tuple!(int, "code", string, "msg") getError();
 auto e = getError;


 Andrei


  Imagine 'code' and 'msg' are already there as local variables and you  
 want to reuse them. How should you do this?


 I've been thinking of defining a simple function that binds to variable  
 addresses and allows assignment from a tuple, in which case the code  
 would be:

 group(&code, &msg) = getError;

 In "the future" we'll have variadic ref arguments, in which case the  
 "&"s can be dropped:

 group(code, msg) = getError;

 Also in "the future" variable definitions will be expressions, in which  
 case the code to define and assign code and msg becomes:

 group(int code, string msg) = getError;


 Andrei


Hmmm, this is almost as nice (inspired by jQuery):

$(code, msg) = getError(); // :)
Nov 01 2008
parent reply downs <default_357-line yahoo.de> writes:
Denis Koroskin wrote:

 On Sat, 01 Nov 2008 19:33:01 +0300, Andrei Alexandrescu
 <SeeWebsiteForEmail erdani.org> wrote:
 

 Denis Koroskin wrote:

 On Sat, 01 Nov 2008 19:04:16 +0300, Andrei Alexandrescu
 <SeeWebsiteForEmail erdani.org> wrote:


 KennyTM~ wrote:

 ore-sama wrote:

 4tuu4k002 sneakemail.com Wrote:



 int, int getPoint();
 int a,b;
 a,b = getPoint();


 Provided we have lvalue array literals, this can fit to general
 array operations rules:
 int[] getPoint();
 int a,b;
 [a,b]=getPoint();


  int code;
 string msg;
  [code, msg] = getError();


 Tuple!(int, "code", string, "msg") getError();
 auto e = getError;


 Andrei


  Imagine 'code' and 'msg' are already there as local variables and
 you want to reuse them. How should you do this?


 I've been thinking of defining a simple function that binds to
 variable addresses and allows assignment from a tuple, in which case
 the code would be:

 group(&code, &msg) = getError;

 In "the future" we'll have variadic ref arguments, in which case the
 "&"s can be dropped:

 group(code, msg) = getError;

 Also in "the future" variable definitions will be expressions, in
 which case the code to define and assign code and msg becomes:

 group(int code, string msg) = getError;


 Andrei


 
 Hmmm, this is almost as nice (inspired by jQuery):
 
 $(code, msg) = getError(); // :)


Sure.

$ is not an identifier, but this will work.

import tools.base;

alias ptuple _;

Stuple!(int, string) test() { return stuple(4, "foo"); }

void main() { int a; string b; _(a, b) = test(); }

:)
Nov 03 2008
parent Robert Fraser <fraserofthenight gmail.com> writes:
downs wrote:

 Denis Koroskin wrote:

 On Sat, 01 Nov 2008 19:33:01 +0300, Andrei Alexandrescu
 <SeeWebsiteForEmail erdani.org> wrote:


 Denis Koroskin wrote:

 On Sat, 01 Nov 2008 19:04:16 +0300, Andrei Alexandrescu
 <SeeWebsiteForEmail erdani.org> wrote:


 KennyTM~ wrote:

 ore-sama wrote:

 4tuu4k002 sneakemail.com Wrote:



 int, int getPoint();
 int a,b;
 a,b = getPoint();


 Provided we have lvalue array literals, this can fit to general
 array operations rules:
 int[] getPoint();
 int a,b;
 [a,b]=getPoint();


  int code;
 string msg;
  [code, msg] = getError();


 Tuple!(int, "code", string, "msg") getError();
 auto e = getError;


 Andrei


  Imagine 'code' and 'msg' are already there as local variables and
 you want to reuse them. How should you do this?


 I've been thinking of defining a simple function that binds to
 variable addresses and allows assignment from a tuple, in which case
 the code would be:

 group(&code, &msg) = getError;

 In "the future" we'll have variadic ref arguments, in which case the
 "&"s can be dropped:

 group(code, msg) = getError;

 Also in "the future" variable definitions will be expressions, in
 which case the code to define and assign code and msg becomes:

 group(int code, string msg) = getError;


 Andrei


 Hmmm, this is almost as nice (inspired by jQuery):

 $(code, msg) = getError(); // :)


 
 Sure.
 
 $ is not an identifier, but this will work.
 
 import tools.base;
 
 alias ptuple _;
 
 Stuple!(int, string) test() { return stuple(4, "foo"); }
 
 void main() { int a; string b; _(a, b) = test(); }
 
 :)


$(a, b);
_(a, b);

*has flashbacks to his days in the jungles of Perl*
Nov 03 2008
prev sibling parent reply Frits van Bommel <fvbommel REMwOVExCAPSs.nl> writes:
Andrei Alexandrescu wrote:

 I've been thinking of defining a simple function that binds to variable 
 addresses and allows assignment from a tuple, in which case the code 
 would be:
 
 group(&code, &msg) = getError;
 
 In "the future" we'll have variadic ref arguments, in which case the 
 "&"s can be dropped:
 
 group(code, msg) = getError;


I've managed to make this work right now:
	group!(code, msg) = getError();

as well as (with a different function):
	group_!(code, msg) = getError();
	auto myGroup = group_!(code, msg);
	myGroup = getError();
(The second example has several implementations in fact. Unfortunately, 
all of them currently allocate a closure for the variables if they're 
local. The first one doesn't have that problem)

All of this is D2+Phobos, by the way. Though something similar could 
likely be made in D1 (minus the closure issues, obviously).


Unfortunately it does have a severe limitation: it only works on 
straight variables because it uses alias template parameters.
You can't assign to *b or foo.a, for instance (unless it's static).

See attachment for code.
Nov 01 2008
parent reply bearophile <bearophileHUGS lycos.com> writes:
Frits van Bommel:

 I've managed to make this work right now:


[...]

Take a look at the Record!(), record in my libs (for D1), in modules templates
 and func
http://www.fantascienza.net/leonardo/so/libs_d.zip

Bye,
bearophile
Nov 01 2008
parent reply Andrei Alexandrescu <SeeWebsiteForEmail erdani.org> writes:
bearophile wrote:

 Frits van Bommel:

 I've managed to make this work right now:


 [...]
 
 Take a look at the Record!(), record in my libs (for D1), in modules templates
  and func
 http://www.fantascienza.net/leonardo/so/libs_d.zip


Is there a link to online documentation?

Andrei
Nov 01 2008
parent bearophile <bearophileHUGS lycos.com> writes:
Andrei Alexandrescu:

 Is there a link to online documentation?


Yes, there is (only because you are one of the most gentle persons of this
newsgroup):
http://www.fantascienza.net/leonardo/so/dlibs/all.html

The form of that page will improve later.

Bye,
bearophile
Nov 01 2008
prev sibling next sibling parent reply ore-sama <spam here.lot> writes:
KennyTM~ Wrote:


 Right. It should be a tuple instead of an array for more generic variants.
 
 I think this (x, y) = ... is just as good as [x, y] = ...


this is useless :P use structs or arrays.
Nov 01 2008
parent KennyTM~ <kennytm gmail.com> writes:
ore-sama wrote:

 KennyTM~ Wrote:
 

 Right. It should be a tuple instead of an array for more generic variants.

 I think this (x, y) = ... is just as good as [x, y] = ...


 
 this is useless :P use structs or arrays.


Think of it as another syntactic sugar :p
Nov 01 2008
prev sibling parent bearophile <bearophileHUGS lycos.com> writes:
ore-sama:

 KennyTM~ Wrote:

 Right. It should be a tuple instead of an array for more generic variants.
 I think this (x, y) = ... is just as good as [x, y] = ...


 
 this is useless :P use structs or arrays.


With my libs you can do:

import d.all;
Record!(string, int) foo() {
    return record("hello"[], 10);
}
void main() {
    auto s_i = foo();
    putr(s_i.d0, " ", s_i.d1); // Output: hello 10
}

Or:

import d.all;
Record!(string, int) foo() {
    return record("hello"[], 10);
}
void main() {
    string s;
    int i;
    derecord(foo(), s, i);
    putr(s, " ", i);
}

In D2 the first version will become:
import d.all;
auto foo() {
    return record("hello"[], 10);
}
void main() {
    auto s_i = foo();
    putr(s_i.d0, " ", s_i.d1); // Output: hello 10
}

Those Record are structs with several handy methods, they can be joined, cmp,
hashed, etc. Even if they recursively contain other kinds of generic structs
(not just other Record).
With this I don't miss a built-in multiple return too much, while we wait to
have it built-in.

Bye,
bearophile
Nov 01 2008