I'm curious about how Function Capturing is achieved.

[xialvjun]

pub fn run() {
  let add_one = add(1, _)
  add_one(2)
}

is

pub fn run() {
  let add_one = fn(x) { add(1, x) }
  add_one(2)
}

vs

pub fn run() {
  return fn(x) {
    let add_one = add(1, x)
    return add_one(2)
  }
}

[lpil]

It's the first one! one(_, 2) expands to fn(x) { one(x, 2) }

[xialvjun]

So, the compiler will transform the shortest expression to a function ?

abc(_ + 1, 3)

// expands to
abc(fn(x) { x + 1 }, 3)

// rather than
fn(x) { abc(x + 1, 3) }

If so, what if abc(_ + 1 + 2) ? abc(fn(x) { x + 1 } + 2) or abc(fn(x) { x + 1 + 2 })

[lpil]

The capture syntax only works for function calls, so _ + 1 in that first example isn't supported and will be a compile error.

[xialvjun]

abc(def(_))

// is
abc(fn(x) { def(x) })

// not
fn(x) { x |> def |> abc }

If so, I feel like Function Capturing is easy to misuse.

How about the shortest expression except _ itself or long expression bracketed with #{xxxxxx}. If so, then:

abc(def(_))
// is
abc(fn(x) { def(x) })

#{abc(def(_))}
// is
fn(x) { x |> def |> abc }

Maybe that's too complicated, will make code easy to write, hard to read. I don't know.
As a user, I just want strict and simple use of syntax.

[lpil]

Totally! We want it strict and simple too so it is limited to just functions and isn't recursive. Very simple and predictable.

[xialvjun]

Yeah, thanks. Maybe abc(def(_)) is a little misleading, but it should be ok after we get used to it.