Take latest message from a tokio mpsc channel

Question

I'm receiving messages from 2 channels every second and every 2 seconds, respectively. There is a function that needs to be run every time a message is received but this function takes 5 seconds. We're filling up the result channel way quicker than the time it takes for the expensive function to finish.

The output of the below code looks something like this:

foo0
bar0
foo1
foo2
bar1
foo3
foo4
Data: {"processed-foo0": 0.7808990900831444}
bar2
foo5
foo6
bar3
foo7
foo8
bar4
foo9
Data: {"processed-foo0": 0.7808990900831444, "processed-bar0": 0.18431127449026619}
foo10
bar5
...

The expensive function is always run using the next message from the queue, not the latest and so it falls behind.

How do I run the expensive function using the latest message from the result channel?

use std::{
    collections::HashMap,
    time::Duration,
    sync::Arc,
};
use futures::future; // 0.3.21
use tokio::{
    sync::{
        mpsc::{self, UnboundedSender},
        Mutex,
    },
    time,
}; // 1.16.1
use rand::Rng; // 0.8.5
use rand::rngs::StdRng;
use rand::SeedableRng;

pub struct Run;

impl Run {
    async fn expensive_fn(data: Arc<Mutex<HashMap<String, f64>>>, message: &str) {
        let mut rng: StdRng = SeedableRng::from_entropy();
        let mut guard = data.lock().await;
        guard.insert(message.to_string().clone(), rng.gen::<f64>());

        time::sleep(Duration::from_millis(5_000)).await;
    }

    fn fast_fn(message: &str) -> String {
        format!("processed-{message}")
    }
}

async fn message_sender(msg: &str, tx: UnboundedSender<String>) {
    for count in 0.. {
        let message = format!("{msg}{count}");

        if msg == "foo" {
            time::sleep(Duration::from_millis(1_000)).await;
        } else {
            time::sleep(Duration::from_millis(2_000)).await;
        }

        tx.send(message).unwrap();
    }
}

#[tokio::main]
async fn main() {
    let (result_tx, mut result_rx) = mpsc::unbounded_channel();

    let (foo_tx, mut foo_rx) = mpsc::unbounded_channel();
    let (bar_tx, mut bar_rx) = mpsc::unbounded_channel();

    let foo_sender_handle = tokio::spawn(message_sender("foo", foo_tx));
    let bar_sender_handle = tokio::spawn(message_sender("bar", bar_tx));

    let receive_handle = tokio::spawn(async move {
        loop {
            tokio::select! {
                Some(foo_msg) = foo_rx.recv() => {
                    println!("{foo_msg}");
                    let result = Run::fast_fn(&foo_msg);
                    result_tx.send(result).unwrap();
                },
                Some(bar_msg) = bar_rx.recv() => {
                    println!("{bar_msg}");
                    let result = Run::fast_fn(&bar_msg);
                    result_tx.send(result).unwrap();
                },
            }
        }
    });

    let expensive_fn_handle = tokio::spawn(async move {
        let data = Arc::new(Mutex::new(HashMap::new()));
        loop {
            tokio::select! {
                Some(result) = result_rx.recv() => {
                    Run::expensive_fn(data.clone(), &result).await;
                }
            }
            println!("Data: {:?}", data.lock().await);
        }
    });

    future::join_all([foo_sender_handle, bar_sender_handle, receive_handle, expensive_fn_handle]).await;
}