Implicit call for function with no arguments

[shurko0x4cfd]

Something like getter but with no object. Assume will be keyword e.g. "ic" instead of empty parentheses (). The idea is call and get result with no explicit invoke with ().

Now

fn = () -> something...
expression = fn() + '345'

Desired

fn = ic -> something...
expression = fn + '345'

Also for functions binded with JS .bind if it no more need arguments.
Desired

fn = (arg) -> something...
fn2 = ic fn.bind ...someArgs
expression = fn2 + '345'

[edemaine]

This would prevent functions from being first-order. For example, you could no longer write:

fn3 = fn2

(it would end up calling fn2)

Maybe certain functions could be "blessed" to be auto-called? But I don't think it makes sense as a default behavior. First-order functions are too important.

Speaking of "something like getter but with no object", I think let decorators might be a reasonable approach.

[shurko0x4cfd]

This would prevent functions from being first-order

In general, there are mechanisms to pull the function back. For example, in the Forth language there is a word ', which returns the execution token, in fact, these are first-order functions. Applied to the case, it may look a little different. For example, there may be a pseudo property .fn, which contains the function itself.

funame = ic -> something...
expression = funame + '345'

setTimeout funame.fn

[STRd6]

Something fancy we may be able to do in the far future is auto invoke based on type information:

declare f: () => number

x := 5 + f

const x = 5 + f()

Even crazier:

declare f: () => Promise<number>

x := f + 3

const x = (await f()) + 3

It seems possible for common cases but the edge cases could be a nightmare.