Simple Thread Implementations in Rust

main.rs

use std::os;

fn main() {
        let (tx, rx) = channel();

        let args = os::args();
        let mut max_messages: uint = 10u;

        println!("Command line args len: {}", args.len());

        if args.len() > 1 {
                max_messages = match args.last() {
                        Some(n) => {
                                match from_str(n.as_slice().trim()) {
                                        Some(num) => num,
                                        None => 10u
                                }
                        },
                        None => 10u
                }
        }

        println!("Max messages: {}", max_messages);

        spawn(proc() {
                let mut index = 1u;
                loop {
                        println!("Sender -> Sending {}", index);
                        tx.send(index);
                        index = index+1;
                        if index > max_messages {
                                break;
                        }
                }
        });

        spawn(proc() {
                loop {
                        match rx.recv_opt() {
                                Ok(ref x) => println!("Receiver <- Received {}", *x),
                                Err(e) => {
                                        println!("Remote Task Complted! {}", e);
                                        break
                                }
                        }
                }
        });
}