ranger

Types

pub type Options(item_type, step_type) {
  Options(
    validate: fn(item_type) -> Bool,
    negate_step: fn(step_type) -> step_type,
    add: fn(item_type, step_type) -> item_type,
    compare: fn(item_type, item_type) -> order.Order,
  )
}

Constructors

  • Options(
      validate: fn(item_type) -> Bool,
      negate_step: fn(step_type) -> step_type,
      add: fn(item_type, step_type) -> item_type,
      compare: fn(item_type, item_type) -> order.Order,
    )
pub opaque type Range(item_type)

Functions

pub fn create(options: Options(a, b)) -> fn(a, a, b) ->
  Result(Range(a), Nil)

returns a function that can be used to create a range

Examples

> let options =
>   Options(
>     validate: fn(a) { string.length(a) == 1 },
>     negate_step: fn(s) { -1 * s },
>     add: fn(a: String, b: Int) {
>       let [code] = string.to_utf_codepoints(a)
>       let int_code = string.utf_codepoint_to_int(code)
>       let new_int_code = int_code + b
>       let assert Ok(new_code) = string.utf_codepoint(new_int_code)
>       string.from_utf_codepoints([new_code])
>     },
>     compare: string.compare,
>   )
> let range = create(options)

> range("ab", "e", 1)
Error(Nil)

> let assert Ok(a_to_e) = range("a", "e", 1)
> a_to_e |> unwrap |> iterator.to_list
["a", "b", "c", "d", "e"]

> let assert Ok(z_to_p) = range("z", "p", 1)
> z_to_p |> unwrap |> iterator.to_list
["z", "y", "x", "w", "v", "u", "t", "s", "r", "q", "p"]

> let assert Ok(z_to_p) = range("z", "p", -2)
> z_to_p |> unwrap |> iterator.to_list
["z", "x", "v", "t", "r", "p"]

> let assert Ok(z_to_p) = range("z", "p", 3)
> z_to_p |> unwrap |> iterator.to_list
["z", "w", "t", "q"]
> let options =
>   Options(
>     validate: fn(_) { True },
>     negate_step: fn(s) { -1.0 *. s },
>     add: fn(a, b) { a +. b },
>     compare: float.compare,
>   )
> let range = create(options)

> let assert Ok(weird_step_case) = range(1.25, 4.5, -0.5)
> weird_step_case |> unwrap |> iterator.to_list
[1.25, 1.75, 2.25, 2.75, 3.25, 3.75, 4.25]

> let assert Ok(single_item_case) = range(1.25, 1.25, -0.25)
> single_item_case |> unwrap |> iterator.to_list
[1.25]

> let assert Ok(zero_step_case) = range(2.5, 5.0, 0)
> zero_step_case |> unwrap |> iterator.to_list
[2.5]
pub fn unwrap(value: Range(a)) -> Iterator(a)
Search Document