# Include the external dependency itself as a module named "slow_api"
use extern "slowapi" as slow_api;

# Use some things from the "slow_api" module
use std::serde::Serializable;
use std::serde::format::Json;

use slow_api::{SlowAPI, Method};

# Construct a slow API server
val server = SlowApi();

type Person derives Serializable = {
    name: String,
    age: Option<String>
};

fn hello_route(
    name: Argument<String>, 
    age: Argument<Option<String>>,
) -> Json<Person> {
    Person { name, age }
}

# Start the server
server
    .route(Method::GET, "/hello", hello_route)
    .start("0.0.0.0:8000");
#










































###
type Poggies;

trait Constructor<..T> {
    fn new(..T) -> Self;
}

impl Constructor<> for Poggies {
    fn new() -> Self {
        #
    }
}

impl<T: Constructor<>> Default for T {
    fn default() -> Self {
        Self::new()
    }
}

###
type Person = {
    name: String,
    age: i32,
};

type Person derives Serialize, Deserialize = {
    name: String,
    age: i32,
};

@route::get("/teacup") #      vvvvvv - Requires T to implement Serialize
fn teacup_route() -> Response<Person> {
    Response(418, Person {
        name: "Cody Q",
        age: 17,
    })
}