# Functor BatBounded.Make

    module Make: functor (M : BoundedType) -> S  with type base_u = M.base_t
      with type u = M.t
      with type t = private M.t

Functor to build an implementation of a bounded type given the bounded values definition `M`

Parameters: |
`M` | : | `BoundedType`

    type base_u

Raw unbounded type

    type u

`BatBounded.S.base_u` after bounding constraints have been applied

    type t = private u

Private version of `BatBounded.S.u` to avoid construction of `BatBounded.S.t` values without using `make` below.

    val bounds : base_u BatBounded.bound_t *
           base_u BatBounded.bound_t

`bounds` defines the `(min, max)` bounds for the bounded range

    val make : base_u -> t

`make x` will return a value of type `BatBounded.S.t` derived from `x`.

    val extract : t -> u

`extract x` will return `x` as a value of type `BatBounded.S.u`. A similar result could be achieved with `(x :> u)`

    val map : (base_u -> base_u) ->
           t -> t option

`map f x` applies `f` to `x`. Returns `Some y` if `x` can be converted back to type `BatBounded.S.base_u`, otherwise returns `None`.

    val map2 : (base_u -> base_u -> base_u) ->
           t -> t -> t option

`map f x y` applies `f` to `x` and `y`. Returns `Some z` if `x` and `y` can be converted back to type `BatBounded.S.base_u`, otherwise returns `None`.

    val map_exn : (base_u -> base_u) ->
           t -> t

`map_exn f x` applies `f` to `x`. Returns `y` if `x` can be converted back to type `BatBounded.S.base_u`, otherwise raise an exception.

    val map2_exn : (base_u -> base_u -> base_u) ->
           t -> t -> t

`map f x y` applies `f` to `x` and `y`. Returns `z` if `x` and `y` can be converted back to type `BatBounded.S.base_u`, otherwise raise an exception.