arrow functions or lambda functions support

[blueway]

like es arrow function (x,y) => x+y or like python lambda function g = lambda x:x+1

[xushiwei]

Thank you for your proposal. We will consider it seriously.

[xushiwei]

Define lambda functions

f := (arg1 ArgType1, arg2 ArgType2, ..., argN ArgTypeN) => expr(arg1, arg2, ..., argN)

g := (arg1 ArgType1, arg2 ArgType2, ..., argN ArgTypeN) => {
    ...
    return expr(arg1, arg2, ..., argN)
} 

Note: output parameters are always omitted.

Passing lambda functions as function parameters

foo.Bar(arg => expr(arg))
foo.Bar((arg1, arg2, ..., argN) => expr(arg1, arg2, ..., argN))
foo.Bar((arg1, arg2, ..., argN) => {
    ...
    return expr(arg1, arg2, ..., argN)
})

Types of input parameters can be omitted if they can be automatically deduced.

For example, in Go we can write code as following:

foo.Map(func(x float64) float64 { return x*x })

And in Go+ it can be:

foo.Map(x => x*x)

[damonchen]

If we write the code below:

m := 100
cc := (arg1, arg2, arg3) => {
    m := 10

    dd := (d1, d2, d3) => {
        println(m);
    }
}

what is the print? or compile error?

[mlboy]

I'd like ES6 style

[xushiwei]

If we write the code below:

m := 100
cc := (arg1, arg2, arg3) => {
    m := 10

    dd := (d1, d2, d3) => {
        println(m);
    }
}

what is the print? or compile error?

Will compile fail because types of input parameters are not specified. If we do this, its output is "10\n".

[xushiwei]

Define lambda functions

f := (arg1 ArgType1, arg2 ArgType2, ..., argN ArgTypeN) => expr(arg1, arg2, ..., argN)

g := (arg1 ArgType1, arg2 ArgType2, ..., argN ArgTypeN) => {
    ...
    return expr(arg1, arg2, ..., argN)
} 

Note: output parameters are always omitted.

To make the following code

foo.Map(x => x*x)

equals to

f := x => x*x
foo.Map(f)

We automatically deduce the prototype of lambda f till first time it is used.

So, Defining lambda functions will be same as passing them as function parameters.

f1 := arg => expr(arg)
f2 := arg => {
    ...
    return expr(arg)
}
g1 := (arg1, arg2, ..., argN) => expr(arg1, arg2, ..., argN)
g2 := (arg1, arg2, ..., argN) => {
    ...
    return expr(arg1, arg2, ..., argN)
}

[shendiaomo]

x => x*x

How to write a lambda without parameters and multiple return values?

f1 := => expr1, expr2

or

f1 := () => (expr1, expr2)

[xushiwei]

How to write a lambda without parameters and multiple return values?

f1 := => expr1, expr2

or

f1 := () => (expr1, expr2)

Will be:

f1 := => (expr1, expr2)  // or:
f1 := () => (expr1, expr2)