gotham

Gotham is a flexible web framework for Rust that emphasizes type safety, ergonomics, and speed. It provides a modular architecture that allows developers to build robust and scalable web applications with ease, leveraging Rust's powerful type system and performance characteristics.

Pros

• Strong focus on type safety and compile-time checks
• Modular design allowing for easy customization and extension
• High performance due to Rust's efficiency and zero-cost abstractions
• Comprehensive documentation and examples for quick learning

Cons

• Steeper learning curve compared to some other web frameworks
• Smaller community and ecosystem compared to more established frameworks
• May be overkill for simple web applications or microservices
• Requires understanding of Rust's ownership and borrowing concepts

Code Examples

1. Basic "Hello, World!" handler:

use gotham::state::State;

fn say_hello(state: State) -> (State, &'static str) {
    (state, "Hello, World!")
}

fn main() {
    let addr = "127.0.0.1:7878";
    println!("Listening for requests at http://{}", addr);
    gotham::start(addr, || Ok(say_hello))
}

2. Handling path parameters:

use gotham::state::State;
use gotham::handler::IntoResponse;
use gotham::helpers::http::response::create_response;
use gotham::router::builder::*;
use gotham::hyper::{Body, Response, StatusCode};

fn user_handler(state: State) -> (State, impl IntoResponse) {
    let user_id = state.borrow::<gotham::state::FromState>().unwrap();
    let response = create_response(
        &state,
        StatusCode::OK,
        mime::TEXT_PLAIN,
        format!("User ID: {}", user_id),
    );
    (state, response)
}

fn router() -> Router {
    build_simple_router(|route| {
        route.get("/user/:id").to(user_handler);
    })
}

fn main() {
    let addr = "127.0.0.1:7878";
    println!("Listening for requests at http://{}", addr);
    gotham::start(addr, router())
}

3. Middleware example:

use gotham::handler::HandlerFuture;
use gotham::middleware::Middleware;
use gotham::state::State;

#[derive(Clone, NewMiddleware)]
struct TimingMiddleware;

impl Middleware for TimingMiddleware {
    fn call<Chain>(self, state: State, chain: Chain) -> HandlerFuture
    where
        Chain: FnOnce(State) -> HandlerFuture,
    {
        let start = std::time::Instant::now();
        let f = chain(state);
        f.map(move |(state, response)| {
            let duration = start.elapsed();
            println!("Request took: {:?}", duration);
            (state, response)
        })
    }
}

// Use in router: pipeline.add(TimingMiddleware::new());

Getting Started

To start using Gotham, add it to your Cargo.toml:

[dependencies]
gotham = "0.7.1"

Then, create a basic "Hello, World!" application:

use gotham::state::State;

fn say_hello(state: State) -> (State, &'static str) {
    (state, "Hello, World!")
}

fn main() {
    let addr = "127.0.0.1:7878";
    println!("Listening for requests at http://{}", addr);
    gotham::start(addr, || Ok(say_hello))
}

Run the application with cargo run and visit http://localhost:7878 in your browser.