# HTTP Server

Build a simple HTTP server with effect-tracked I/O. The type signature tells you exactly what side effects this code performs.

server.lux

    // A simple HTTP server in Lux
    // Notice the effect signature: {HttpServer, Console}

    fn handleRequest(req: Request): Response = {
        match req.path {
            "/" => Response {
                status: 200,
                body: "Welcome to Lux!"
            },
            "/api/hello" => Response {
                status: 200,
                body: Json.stringify({ message: "Hello, World!" })
            },
            _ => Response {
                status: 404,
                body: "Not Found"
            }
        }
    }

    fn main(): Unit with {HttpServer, Console} = {
        HttpServer.listen(8080)
        Console.print("Server listening on http://localhost:8080")

        loop {
            let req = HttpServer.accept()
            Console.print(req.method + " " + req.path)

            let response = handleRequest(req)
            HttpServer.respond(response.status, response.body)
        }
    }

    run main() with {}

## Key Concepts

- `with {HttpServer, Console}` - The function signature declares exactly which effects this code uses
- `HttpServer.listen(port)` - Start listening on a port
- `HttpServer.accept()` - Wait for and return the next request
- `HttpServer.respond(status, body)` - Send a response
- Pattern matching on `req.path` for routing

## Why Effects Matter Here

- The type signature `with {HttpServer, Console}` tells you this function does network I/O and console output
- Pure functions like `handleRequest` have no effects - they're easy to test
- For testing, you can swap the `HttpServer` handler to simulate requests without a real network

### Run It

    $ lux run server.lux
    Server listening on http://localhost:8080

    # In another terminal:
    $ curl http://localhost:8080/
    Welcome to Lux!

    $ curl http://localhost:8080/api/hello
    {"message":"Hello, World!"}