Function handler 

pub fn handler<F, T>(f: F) -> Arc<dyn Handler>
where
    F: IntoHandler<T>,

Converts an async function into a handler.

This is the main function you use to create handlers from async functions. It automatically detects the function signature and creates the appropriate handler implementation.

Type Inference

The function uses type inference to determine the extractor types. You don’t need to specify any type parameters explicitly.

Examples

Simple Handler

use wsforge::prelude::*;

async fn echo(msg: Message) -> Result<Message> {
    Ok(msg)
}

let router = Router::new()
    .default_handler(handler(echo));

Handler with State

use wsforge::prelude::*;
use std::sync::Arc;

async fn broadcast(
    msg: Message,
    State(manager): State<Arc<ConnectionManager>>,
) -> Result<()> {
    manager.broadcast(msg);
    Ok(())
}

let router = Router::new()
    .default_handler(handler(broadcast));

Handler with Multiple Extractors

use wsforge::prelude::*;
use serde::Deserialize;
use std::sync::Arc;

#[derive(Deserialize)]
struct GameMove {
    player_id: u64,
    action: String,
}

async fn process_move(
    Json(game_move): Json<GameMove>,
    conn: Connection,
    State(manager): State<Arc<ConnectionManager>>,
) -> Result<String> {
    println!("Player {} from {} made move: {}",
        game_move.player_id, conn.id(), game_move.action);

    manager.broadcast_except(conn.id(),
        Message::text(format!("Player {} moved", game_move.player_id)));

    Ok("Move processed".to_string())
}

let router = Router::new()
    .route("/game/move", handler(process_move));

Handler Returning JSON

use wsforge::prelude::*;
use serde::Serialize;

#[derive(Serialize)]
struct Stats {
    users: u32,
    messages: u64,
}

async fn get_stats() -> Result<JsonResponse<Stats>> {
    Ok(JsonResponse(Stats {
        users: 42,
        messages: 1337,
    }))
}

let router = Router::new()
    .route("/stats", handler(get_stats));