"Unable to infer enough type information" when spawning thread and looping.

[jfager]

use std::thread;

fn main() {
    thread::Thread::spawn(move || {
        loop { // Remove the loop and everything works fine.
            println!("hello");
        }
        // This gives you:
        //
        // type_inf.rs:4:5: 4:26 error: unable to infer enough type information about `_`; type annotations required
        // type_inf.rs:4     thread::Thread::spawn(move || {
        //                   ^~~~~~~~~~~~~~~~~~~~~
        // error: aborting due to previous error


        // Uncomment the `()` below, and the error changes to a warning:
        //
        // type_inf.rs:8:9: 9:6 warning: unreachable expression, #[warn(unreachable_code)] on by default
        // type_inf.rs:8         ()
        // type_inf.rs:9     }).detach();

        // ()
    }).detach();
}

$ rustc --version
rustc 0.13.0-nightly (39d7402 2015-01-01 15:51:08 +0000)

[jfager]

Replacing loop with while true spits out a warning to use loop instead but compiles and runs as expected.

[alexcrichton]

This is largely because the spawn function has a type parameter T indicating the return value of the closure.

In the case of loop, the closure return value cannot be inferred (as the function never returns). In the case of while the closure return value is () because the compiler assumes all while loops eventually terminate.

To use loop, you can invoke spawn like so:

Thread::spawn(|| -> T {
    loop { /* ... */ }
});

Here the -> T is a manual ascription of what the return type should be, and it can be -> () to say that it's the "unit return value"

Actually, for diverging type variables (which is what a loop without a break gets typeck'ed to) we normally fall back to (). However, that happens at the very end of type checking and so the fall back will not be used for dispatch resolution. Maybe we should do it earlier, then.

[viperscape]

Here's the same issue:

use std::thread::Thread;
use std::sync::mpsc::{channel};

fn main() {
    let (chs,chr) = channel();

    Thread::spawn(move || {
        chs.send(1u8); //must specifically annotate
    });
}

As seen here

It took me a bit to realize the issue was actually regarding the channel type, as I thought it was referring to the thread's move fn itself with the error:

error: unable to infer enough type information about `closure[<anon>:8:24: 10:6]`; type annotations required
<anon>:8     Thread::spawn(move || {
             ^~~~~~~~~~~~~

[sixohsix]

I'm stuck with the same-looking bug, but the loop is apparently not the cause:

    for i in range(0, 4) {
        let my_numbers = shared_numbers.clone();
        let my_frame_counter = shared_frame_counter.clone();
        Thread::spawn(move || -> () {
            loop {
                my_numbers[i] = (my_frame_counter.frame() / i as i32) % 240;
                t::delay(16);
            }
            return ();
        });
    }

When I comment-out the my_numbers[i] = line, I get no errors. When the line is there, I get the error.

error: unable to infer enough type information about `closure[/Users/XXX/projects/rust-test/src/main.rs:109:28: 115:10]`; type annotations required
/Users/XXX/projects/rust-test/src/main.rs:109         Thread::spawn(move || -> () {
                                                      ^~~~~~~~~~~~~
error: aborting due to previous error

Unfortunately I don't yet know enough to figure out what's wrong with that line. However, the error message is extremely confusing.

[sixohsix]

My mistake was trying to use mutable state across threads. Using AtomicUsize solved the problem. To be clear: the only issue is that the message "unable to infer enough type information" is confusing because it has nothing to do with the real problem. The loop statement without break caused no problems for me.

[starwing]

I have the same issue event with the program in "A 30-minute Introduction to Rust":

use std::thread::Thread;
use std::sync::{Arc,Mutex};

fn main() {
    let numbers = Arc::new(Mutex::new(vec![1, 2, 3]));

    for i in range(0, 3) {
        let number = numbers.clone();
        Thread::spawn(|&:| {
            let i = 5;
            let mut array = number.lock().unwrap();
            (*array)[i] += 1;
            println!("numbers[{}] is {}", i, (*array)[i]);
        });
    }
}

it has the same error:

noname\2015-01-26-1.rs|9 col 9| 9:22 error: unable to infer enough type information about `closure[noname\2015-01-26-1.rs:9:23: 14:10]`; type annotations required [E0282]
|| noname\2015-01-26-1.rs:9         Thread::spawn(|&:| {
||                                  ^~~~~~~~~~~~~
|| error: aborting due to previous error
|| rustc returned 101