sark 0.1.0

Simple Asynchronous Rust webKit
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

# SARK

**S**tatic **A**synchronous **R**ust web frame**K**it

## Overview

SARK is a lightweight, single-threaded asynchronous web framework for Rust, built on top of the monoio runtime. It uses Rust's type system to provide fully static routing with zero dynamic dispatch.

## Features

- Zero dynamic dispatch - fully static routing using Rust's type system
- No `Box<dyn>` or trait objects - maximized compiler optimizations
- Single-threaded async architecture (no `Send`/`Sync` constraints)
- Type-safe request routing and parameter extraction
- State management via generics
- Minimal API surface - easy to learn and use
- Async/await native with AFIT (Async Functions in Traits)

## Example

```rust
use http::Method;
use sark::{
    app::App,
    server::Server,
    service::Service,
    http::{Request, Response},
    error::Result,
};

struct HelloService;

impl Service for HelloService {
    async fn call(&self, _req: Request, _state: &()) -> Result<Response> {
        let mut resp = Response::ok();
        resp.set_body_str("Hello, World!");
        Ok(resp)
    }
}

fn main() -> Result<()> {
    let app = App::default()
        .route(Method::GET, "/", HelloService);

    let mut runtime = monoio::RuntimeBuilder::<monoio::LegacyDriver>::new()
        .build()
        .unwrap();

    runtime.block_on(async {
        Server::bind("127.0.0.1:3000")
            .serve(&app)
            .await
    })
}
```

## Development Status

SARK is currently in early development and is not yet recommended for production use.

## License

MIT