fist - v1.1.0

fist

Types

Node

</>

A node in the router tree, representing a route segment.

pub type Node(req_body, output) {
  Node(
    handler: option.Option(
      fn(request.Request(req_body), dict.Dict(String, String)) -> output,
    ),
    static_children: dict.Dict(String, Node(req_body, output)),
    dynamic_child: option.Option(
      #(String, Node(req_body, output)),
    ),
  )
}

Constructors

Router

opaque </>

A router that handles HTTP requests by matching routes and executing handlers.

pub opaque type Router(req_body, output)

Values

delete

</> 
pub fn delete(
  router: Router(req_body, output),
  path path: String,
  to handler: fn(
    request.Request(req_body),
    dict.Dict(String, String),
  ) -> output,
) -> Router(req_body, output)

Adds a DELETE route to the router.

get

</> 
pub fn get(
  router: Router(req_body, output),
  path path: String,
  to handler: fn(
    request.Request(req_body),
    dict.Dict(String, String),
  ) -> output,
) -> Router(req_body, output)

Adds a GET route to the router.

get_query

</> 
pub fn get_query(
  req: request.Request(mist.Connection),
) -> dict.Dict(String, String)

handle

</> 
pub fn handle(
  router: Router(req_body, output),
  request: request.Request(req_body),
  not_found: fn() -> output,
) -> output

json

</> 
pub fn json(body: String) -> response.Response(String)

Creates a 200 OK response with the given string as body and application/json content type.

map

</> 
pub fn map(
  router: Router(req_body, a),
  with fun: fn(a) -> b,
) -> Router(req_body, b)

Maps the output of all handlers in the router.

new

</> 
pub fn new() -> Router(req_body, output)

Creates a new empty router.

ok

</> 
pub fn ok(body: body) -> response.Response(body)

Creates a 200 OK response with the given body.

patch

</> 
pub fn patch(
  router: Router(req_body, output),
  path path: String,
  to handler: fn(
    request.Request(req_body),
    dict.Dict(String, String),
  ) -> output,
) -> Router(req_body, output)

Adds a PATCH route to the router.

post

</> 
pub fn post(
  router: Router(req_body, output),
  path path: String,
  to handler: fn(
    request.Request(req_body),
    dict.Dict(String, String),
  ) -> output,
) -> Router(req_body, output)

Adds a POST route to the router.

put

</> 
pub fn put(
  router: Router(req_body, output),
  path path: String,
  to handler: fn(
    request.Request(req_body),
    dict.Dict(String, String),
  ) -> output,
) -> Router(req_body, output)

Adds a PUT route to the router.

redirect

</> 
pub fn redirect(to: String) -> response.Response(String)

Creates a 302 Found redirect response.

render_mist

</> 
pub fn render_mist(
  res: response.Response(String),
) -> response.Response(mist.ResponseData)

Renders a Response(String) into a Response(mist.ResponseData) for use with Mist.

route

</> 
pub fn route(
  router: Router(req_body, output),
  method method: http.Method,
  path path: String,
  handler handler: fn(
    request.Request(req_body),
    dict.Dict(String, String),
  ) -> output,
) -> Router(req_body, output)

Inserts a route into the router.

start

</> 
pub fn start(
  router: Router(
    mist.Connection,
    response.Response(mist.ResponseData),
  ),
  port port: Int,
) -> Nil

text

</> 
pub fn text(body: String) -> response.Response(String)

Creates a 200 OK response with the given string as body and text/plain content type.

✨ Search Document