// create an unbounded channel
let (tx, rx) = firefly::mpsc::unbounded();

thread::spawn(move || {
    // send a message across
    tx.send(42).unwrap();
});

// receive the message
assert_eq!(rx.recv_blocking().unwrap(), 42);

// create a channel that can hold at most 10 messages at a time
let (tx, rx) = firefly::mpsc::bounded(10);

thread::spawn(move || {
    for i in 0..100 {
        // send a message, potentially blocking until capacity frees up
        tx.send_blocking(i).unwrap();
    }
});

for _ in 0..100 {
    // wait for a message to be sent
    let i = rx.recv_blocking().unwrap();
    println!("{i}");
}

// create an unbounded channel
let (tx, rx) = firefly::mpsc::unbounded();

thread::spawn(move || {
    // send an infinite amount of messages
    for i in 0.. {
        tx.send(i).unwrap();
    }
});

// receive an infinite amount of messages
loop {
    let i = rx.recv_blocking().unwrap();
    println!("{i}");
}

assert_eq!(x, 42), Err(_) => println!("message took too long to send") } tokio::spawn(async move { // block the async task until the message is sent assert_eq!(rx.recv().await.unwrap(), 42); });">

use std::time::Duration;

let (tx, rx) = firefly::mpsc::bounded(4);

thread::spawn(move || {
    for _ in 0..3 {
        // this can never fail because we only ever send
        // 3 messages, and the capacity is 4
        tx.try_send(42).unwrap();
    }
});

// receive the message or return an error if not immediately ready
match rx.try_recv() {
    Ok(x) => assert_eq!(x, 42),
    Err(_) => println!("message has not been sent yet")
}

// block the thread until the message is sent
assert_eq!(rx.recv_blocking().unwrap(), 42);

// block the thread upto 100ms
match rx.recv_timeout(Duration::from_millis(100)) {
    Ok(x) => assert_eq!(x, 42),
    Err(_) => println!("message took too long to send")
}

tokio::spawn(async move {
    // block the async task until the message is sent
    assert_eq!(rx.recv().await.unwrap(), 42);
});

let (tx, rx) = firefly::mpsc::bounded(10);

thread::spawn(move || {
    // send messages synchronously
    for i in 0.. {
        tx.send_blocking(i).unwrap()
    }
});

tokio::spawn(async move {
    // receive asynchronously
    loop {
        let i = rx.recv().await.unwrap();
        println!("{i}");
    }
});

let (tx, rx) = firefly::mpsc::unbounded();
tx.send(1).unwrap();
tx.send(2).unwrap();

// drop the sender
drop(tx);

// any remaining messages can be received
assert_eq!(r.recv(), Ok(1));
assert_eq!(r.recv(), Ok(2));

// subsequent attempts will error
assert_eq!(r.recv(), Err(RecvError));