Returning a closure from a function

Question

Note: This question was asked before Rust's first stable release. There have been lots of changes since and the syntax used in the function is not even valid anymore. Still, Shepmaster's answer is excellent and makes this question worth keeping.

---

Finally unboxed closures have landed, so I am experimenting with them to see what you can do.

I have this simple function:

fn make_adder(a: int, b: int) -> || -> int {
    || a + b
}

However, I get a missing lifetime specifier [E0106] error. I have tried to fix this by changing the return type to ||: 'static -> int, but then I get another error cannot infer an appropriate lifetime due to conflicting requirements.

If I understand correctly, the closure is unboxed so it owns a and b. It seems very strange to me that it needs a lifetime. How can I fix this?

Answer 1

As of Rust 1.26, you can use impl trait:

fn make_adder(a: i32) -> impl Fn(i32) -> i32 {
    move |b| a + b
}

fn main() {
    println!("{}", make_adder(1)(2));
}

This allows returning an unboxed closure even though it is impossible to specify the exact type of the closure.

This will not help you if any of these are true:

1. You are targeting Rust before this version

2. You have any kind of conditional in your function:

   fn make_adder(a: i32) -> impl Fn(i32) -> i32 {
       if a > 0 {
           move |b| a + b
       } else {
           move |b| a - b
       }
   }
   

   Here, there isn't a single return type; each closure has a unique, un-namable type.

3. You need to be able to name the returned type for any reason:

   struct Example<F>(F);
   
   fn make_it() -> Example<impl Fn()> {
       Example(|| println!("Hello"))
   }
   
   fn main() {
       let unnamed_type_ok = make_it();
       let named_type_bad: /* No valid type here */ = make_it();
   }
   

   You cannot (yet) use impl SomeTrait as a variable type.

In these cases, you need to use indirection. The common solution is a trait object, as described in the other answer.

Answer 2

It is possible to return closures inside Boxes, that is, as trait objects implementing certain trait:

fn make_adder(a: i32) -> Box<dyn Fn(i32) -> i32> {
    Box::new(move |b| a + b)
}

fn main() {
    println!("{}", make_adder(1)(2));
}

(try it here)

There is also an RFC (its tracking issue) on adding unboxed abstract return types which would allow returning closures by value, without boxes, but this RFC was postponed. According to discussion in that RFC, it seems that some work is done on it recently, so it is possible that unboxed abstract return types will be available relatively soon.

Answer 3

The || syntax is still the old boxed closures, so this doesn't work for the same reason it didn't previously.

And, it won't work even using the correct boxed closure syntax |&:| -> int, since it is literally is just sugar for certain traits. At the moment, the sugar syntax is |X: args...| -> ret, where the X can be &, &mut or nothing, corresponding to the Fn, FnMut, FnOnce traits, you can also write Fn<(args...), ret> etc. for the non-sugared form. The sugar is likely to be changing (possibly something like Fn(args...) -> ret).

Each unboxed closure has a unique, unnameable type generated internally by the compiler: the only way to talk about unboxed closures is via generics and trait bounds. In particular, writing

fn make_adder(a: int, b: int) -> |&:| -> int {
    |&:| a + b
}

is like writing

fn make_adder(a: int, b: int) -> Fn<(), int> {
    |&:| a + b
}

i.e. saying that make_adder returns an unboxed trait value; which doesn't make much sense at the moment. The first thing to try would be

fn make_adder<F: Fn<(), int>>(a: int, b: int) -> F {
    |&:| a + b
}

but this is saying that make_adder is returning any F that the caller chooses, while we want to say it returns some fixed (but "hidden") type. This required abstract return types, which says, basically, "the return value implements this trait" while still being unboxed and statically resolved. In the language of that (temporarily closed) RFC,

fn make_adder(a: int, b: int) -> impl Fn<(), int> {
    |&:| a + b
}

Or with the closure sugar.

(Another minor point: I'm not 100% sure about unboxed closures, but the old closures certainly still capture things by-reference which is another thing that sinks the code as proposed in the issue. This is being rectified in #16610.)

Answer 4

Here's how to implement a closure based counter:

fn counter() -> impl FnMut() -> i32 {
    let mut value = 0;

    move || -> i32 {
        value += 1;
        return value;
    }
}

fn main() {
    let mut incre = counter();
    println!("Count 1: {}", incre());
    println!("Count 2: {}", incre());
}