Question about websocket "Read & Write concurrently" example

[SimpleApp]

I'm having trouble understanding how that example :

use axum::{Error, extract::ws::{WebSocket, Message}};
use futures_util::{sink::SinkExt, stream::{StreamExt, SplitSink, SplitStream}};

async fn handle_socket(mut socket: WebSocket) {
    let (mut sender, mut receiver) = socket.split();

    tokio::spawn(write(sender));
    tokio::spawn(read(receiver));
}

async fn read(receiver: SplitStream<WebSocket>) {
    // ...
}

async fn write(sender: SplitSink<WebSocket, Message>) {
    // ...
}

can work in practice : "SplitStream".next() needs mutable borrow, which doesn't seem to be possible, even when trying to change the "async fn read" signature.

The solution i found would be to use something like an Arc<tokio::sync::Mutex<SplitStream<WebSocket>>, but i was hoping for something more elegant.

[jplatte]

What problem were you running into when adding mut before receiver in the read function signature?

[SimpleApp]

"receiver does not live long enough
borrowed value does not live long enough"

[jplatte]

Please can you share the code where you hit that error?

[SimpleApp]

I can't share the whole code, but the entry point really is similar to the example :

// .. somewhere in another file : 
Router::new()
        .route("/", get(|| async { "Hello, World!" }))
        .route("/ws", any(endpoints::handle_ws_connection))
    
// Then in the handler file : 
pub async fn handle_ws_connection(
    ws: WebSocketUpgrade,
    State(_engine): State<std::sync::Arc<engine::Engine>>,
    claims: ClaimsRequestPart,
) -> Response {
    ws.on_upgrade(|socket| on_ws_upgrade(socket, claims.0, _engine))
}

pub async fn on_ws_upgrade(
    socket: WebSocket,
    claims: Claims,
    engine: std::sync::Arc<engine::Engine>,
) {
    tracing::info!("WS connection established for user {}", claims.user_id);
    let (sender, mut receiver) = socket.split();
    tokio::spawn(read(&mut receiver)); // <-- here `receiver` does not live long enough. 
  }
  
  pub async fn read(receiver: &mut SplitStream<WebSocket>) {
    while let Some(message) = receiver.next().await {
        let Ok(message) = message else {
            tracing::error!("WS message is not a valid message");
            continue;
        };
    }
}

[jplatte]

Why receiver: &mut SplitStream<WebSocket>? Try mut receiver: SplitStream<WebSocket>.

[SimpleApp]

Thanks, it seems to have done the trick. I didn't even know one could write mut at this position. Now i'll have to check out what it means in the rust book.
Edit : just did, and it makes a lot of sense indeed. Thanks for the help.