First-class function can't call itself

[thinkpad20]

I'm not sure if this is an issue, but it sure seems to be. The following code:

fn main() {
    let collatz = |i: int, acc: int| -> int {
        if i == 1 { acc }
        else if i % 2 == 0 { collatz(i/2, acc + 1) }
        else { collatz(3*i + 1, acc + 1) }
    };
    println(fmt!("collatz(400) = %d", collatz(400, 0)));
}

Produces the following error on compilation:

> rustc collatz.rs
recurse.rs:4:23: 4:30 error: unresolved name: `collatz`.
recurse.rs:4        else if i % 2 == 0 { collatz(i/2, acc + 1) }
                                         ^~~~~~~
recurse.rs:5:9: 5:16 error: unresolved name: `collatz`.
recurse.rs:5        else { collatz(3*i + 1, acc + 1) }
                           ^~~~~~~
error: aborting due to 2 previous errors

Why is the function not aware of its own name?

[thinkpad20]

Found out you can use an fn declaration for this:

fn main() {
    fn collatz (i: int, acc: int) -> int {
        if i == 1 { acc }
        else if i % 2 == 0 { collatz(i/2, acc + 1) }
        else { collatz(3*i + 1, acc + 1) }
    };
    println(fmt!("collatz(400) = %d", collatz(400, 0)));
}

[Aatch]

@thinkpad20 Hi, I know you solved your problem, but I would like to explain why the first code didn't work. Apologies if you already figured this out, but maybe it'll help somebody else that stumbles across this issue.

For a start let foo = |x| x*x actually creates a closure, which is an anonymous function that potentially captures it's environment and assigns it to foo. Now, you might still be wondering why you couldn't call foo from inside that closure, after all, it is assigned to a variable. An example will help to explain:

fn main() {
  let foo = |x:int| x*x; // This creates a closure assigned to foo

  let foo = |x,y| {
    foo(x) + foo(y) // Which foo gets called?
  }
}

You can use let to introduce a new variable, and Rust really doesn't mind if it's the same name as a previous variable, as long as you don't mind not being able to access the previous variable any more. For this reason, captured variables in a closure are resolved before being assigned in an assignment expression. This provides a single rule for knowing which variables get captured when and where. In the above example, the first foo closure is captured by the second foo closure. A different rule would introduce ambiguity.

Again, apologies if you already worked this out but it doesn't hurt to have another explanation floating around.