wayfinder

Types

DefaultSearchParams

pub type DefaultSearchParams =
  List(#(String, String))

PathSegment

</>

pub type PathSegment {
  Literal(val: String)
  Param(name: String)
}

Constructors

```
Literal(val: String)
```
```
Param(name: String)
```

Route0

</>

pub type Route0(a, b) {
  Route0(
    path: List(PathSegment),
    search: SearchParams(b),
    handler: fn(b) -> a,
  )
}

Constructors

Route0(
  path: List(PathSegment),
  search: SearchParams(b),
  handler: fn(b) -> a,
)

Route1

</>

pub type Route1(a, b) {
  Route1(
    path: List(PathSegment),
    search: SearchParams(b),
    handler: fn(b, String) -> a,
  )
}

Constructors

Route1(
  path: List(PathSegment),
  search: SearchParams(b),
  handler: fn(b, String) -> a,
)

Route2

</>

pub type Route2(a, b) {
  Route2(
    path: List(PathSegment),
    search: SearchParams(b),
    handler: fn(b, String, String) -> a,
  )
}

Constructors

Route2(
  path: List(PathSegment),
  search: SearchParams(b),
  handler: fn(b, String, String) -> a,
)

Route3

</>

pub type Route3(a, b) {
  Route3(
    path: List(PathSegment),
    search: SearchParams(b),
    handler: fn(b, String, String, String) -> a,
  )
}

Constructors

Route3(
  path: List(PathSegment),
  search: SearchParams(b),
  handler: fn(b, String, String, String) -> a,
)

Route4

</>

pub type Route4(a, b) {
  Route4(
    path: List(PathSegment),
    search: SearchParams(b),
    handler: fn(b, String, String, String, String) -> a,
  )
}

Constructors

Route4(
  path: List(PathSegment),
  search: SearchParams(b),
  handler: fn(b, String, String, String, String) -> a,
)

Route5

</>

pub type Route5(a, b) {
  Route5(
    path: List(PathSegment),
    search: SearchParams(b),
    handler: fn(b, String, String, String, String, String) -> a,
  )
}

Constructors

Route5(
  path: List(PathSegment),
  search: SearchParams(b),
  handler: fn(b, String, String, String, String, String) -> a,
)

SearchParams

</>

pub type SearchParams(a) {
  SearchParams(
    decode: fn(List(#(String, String))) -> Result(a, Nil),
    encode: fn(a) -> List(#(String, String)),
  )
}

Constructors

SearchParams(
  decode: fn(List(#(String, String))) -> Result(a, Nil),
  encode: fn(a) -> List(#(String, String)),
)

Wrapper

</>

pub type Wrapper(a, b) {
  Wrapper0(Route0(a, b))
  Wrapper1(Route1(a, b))
  Wrapper2(Route2(a, b))
  Wrapper3(Route3(a, b))
  Wrapper4(Route4(a, b))
  Wrapper5(Route5(a, b))
}

Constructors

```
Wrapper0(Route0(a, b))
```
```
Wrapper1(Route1(a, b))
```
```
Wrapper2(Route2(a, b))
```
```
Wrapper3(Route3(a, b))
```
```
Wrapper4(Route4(a, b))
```
```
Wrapper5(Route5(a, b))
```

Values

default_search_params

</>

pub fn default_search_params() -> SearchParams(
  List(#(String, String)),
)

do_validate

</>

pub fn do_validate(
  routes: List(Wrapper(a, b)),
) -> Result(Nil, String)

get_params1

</>

pub fn get_params1(
  route: Route1(a, b),
  segs: List(String),
) -> Result(#(String), Nil)

get_params2

</>

pub fn get_params2(
  route: Route2(a, b),
  segs: List(String),
) -> Result(#(String, String), Nil)

get_params3

</>

pub fn get_params3(
  route: Route3(a, b),
  segs: List(String),
) -> Result(#(String, String, String), Nil)

get_params4

</>

pub fn get_params4(
  route: Route4(a, b),
  segs: List(String),
) -> Result(#(String, String, String, String), Nil)

get_params5

</>

pub fn get_params5(
  route: Route5(a, b),
  segs: List(String),
) -> Result(#(String, String, String, String, String), Nil)

make_route0

</>

pub fn make_route0(
  path: String,
  search: SearchParams(a),
  handler: fn(a) -> b,
) -> Route0(b, a)

make_route1

</>

pub fn make_route1(
  path: String,
  search: SearchParams(a),
  handler: fn(a, String) -> b,
) -> Route1(b, a)

make_route2

</>

pub fn make_route2(
  path: String,
  search: SearchParams(a),
  handler: fn(a, String, String) -> b,
) -> Route2(b, a)

make_route3

</>

pub fn make_route3(
  path: String,
  search: SearchParams(a),
  handler: fn(a, String, String, String) -> b,
) -> Route3(b, a)

make_route4

</>

pub fn make_route4(
  path: String,
  search: SearchParams(a),
  handler: fn(a, String, String, String, String) -> b,
) -> Route4(b, a)

make_route5

</>

pub fn make_route5(
  path: String,
  search: SearchParams(a),
  handler: fn(a, String, String, String, String, String) -> b,
) -> Route5(b, a)

make_wrap0

</>

pub fn make_wrap0(
  path: String,
  search: SearchParams(a),
  handler: fn(a) -> b,
) -> Wrapper(b, a)

make_wrap1

</>

pub fn make_wrap1(
  path: String,
  search: SearchParams(a),
  handler: fn(a, String) -> b,
) -> Wrapper(b, a)

make_wrap2

</>

pub fn make_wrap2(
  path: String,
  search: SearchParams(a),
  handler: fn(a, String, String) -> b,
) -> Wrapper(b, a)

make_wrap3

</>

pub fn make_wrap3(
  path: String,
  search: SearchParams(a),
  handler: fn(a, String, String, String) -> b,
) -> Wrapper(b, a)

make_wrap4

</>

pub fn make_wrap4(
  path: String,
  search: SearchParams(a),
  handler: fn(a, String, String, String, String) -> b,
) -> Wrapper(b, a)

make_wrap5

</>

pub fn make_wrap5(
  path: String,
  search: SearchParams(a),
  handler: fn(a, String, String, String, String, String) -> b,
) -> Wrapper(b, a)

path_to_segments

</>

pub fn path_to_segments(path: String) -> List(PathSegment)

route_to_path0

</>

pub fn route_to_path0(route: Route0(a, b), params: b) -> String

route_to_path1

</>

pub fn route_to_path1(
  route: Route1(a, b),
  params: b,
  p1: String,
) -> String

route_to_path2

</>

pub fn route_to_path2(
  route: Route2(a, b),
  params: b,
  p1: String,
  p2: String,
) -> String

route_to_path3

</>

pub fn route_to_path3(
  route: Route3(a, b),
  params: b,
  p1: String,
  p2: String,
  p3: String,
) -> String

route_to_path4

</>

pub fn route_to_path4(
  route: Route4(a, b),
  params: b,
  p1: String,
  p2: String,
  p3: String,
  p4: String,
) -> String

route_to_path5

</>

pub fn route_to_path5(
  route: Route5(a, b),
  params: b,
  p1: String,
  p2: String,
  p3: String,
  p4: String,
  p5: String,
) -> String

segs_to_handler

</>

pub fn segs_to_handler(
  segs: List(String),
  query_params: List(#(String, String)),
  routes: List(Wrapper(a, b)),
) -> Result(a, Nil)

segs_to_route

</>

pub fn segs_to_route(
  routes: List(Wrapper(a, b)),
  segs: List(String),
) -> Result(Wrapper(a, b), Nil)

validate

</>

pub fn validate(routes: List(Wrapper(a, b))) -> Nil