Closing a Channel, like in Go

Question

Does Rust have a way of "closing" a channel, similar to what is available in Go?

The idea is to iterate over the channel (receive continually) until the channel indicates that it will not produce any more values.

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

fn main() {
    let data = Arc::new(Mutex::new(0u32));
    let (tx, rx) = mpsc::channel::<u32>();
    {
        let (data, tx) = (data.clone(), tx.clone());
        thread::spawn(move || {
            for _ in 0..10 {
                let mut data = data.lock().unwrap();
                *data += 1;
                tx.send(*data).unwrap();
            }
            // *** How could I close the channel here, to signal the work is done?
        });
    }

    // *** How can I detect a closed channel here? Pattern matching?
    for _ in 0..10 {
        let x = rx.recv().unwrap();
        println!("{}", x);
    }
}

Answer 1

The channel is closed when all Senders have dropped. In your code you clone and give one each to each thread, these drop as they should when the threads end. The last sender is in the main thread, and you should drop it as soon as all the threads have been spawned: drop(tx).

Finally, the easiest way to receive is this, after the drop(tx).

for elt in rx {
    /* */
}

This loop ends when the channel is closed.