by fjanon:

I asked the question at:

https://groups.google.com/group/golang-nuts/browse_thread/thread/ccc2b7dc7d6d7b8e/949385859868c008?lnk=gst&;q=fjanon#

Michael T. Jones CTA @ Google replied and I thought that maybe the Go team could have a
look and decide if it could be added to Go someday.

Thanks.

Original question:

I have been using function addresses for a long time in different 
languages but I miss an *easy* way of getting the address of a 
function with its arguments and then call it later on (lazy eval). 
Right now, storing the arguments and the address of the function in a 
data structure and then calling the function with the arguments stored 
is the only easy way to do it that I know of or currying with the 
extra code required. 
I think that something like 
pf := &somefunc("a str", 1) 
and then 
pf() 
would be useful. 
I know that with closure we can curry functions but it's a bit 
convoluted, there might be a simpler way or syntax to do it. 
Maybe something like that in Go 2.0? 
Fred 

==========================================
Notable difference: 
somefunc signature: 
func name(args) (T2,T3,...) 
f := &somefunc("a str", 1) 
: 
pf() 
compiler knows T2, T3, etc., and can simply do the right thing. 
pf := func () { somefunc("a str", 1) } 
is a perfect example for the asked-for case, but when T2, T3, ... exist 
then the function wrapper must be: 
pf := func () (T2,T3,...) { return somefunc("a str", 1) } 
and the programmer needs to know T2,T3,... and express them perfectly as 
somefunc changes. In the spirit of the C-world's typeof(x), Go could have 
TypeOf(x) and then one could write: 
pf := func () TypeOf(somefunc) { return somefunc("a str", 1) } 
: 
v1, v2, ...vn := pf() 
was would be the case in an expanded version of the original proposal: 
f := &somefunc("a str", 1) 
: 
v1,v2,...vn := pf() 
On Mon, Aug 13, 2012 at 7:06 AM, chris dollin <ehog.he...@googlemail.com>wrote: 

- Show quoted text -
-- 
Michael T. Jones | Chief Technology Advocate  | m...@google.com |  +1 
650-335-5765