This isn't just an int so that if an app adds columns the sort is maintained properly by the app's own classification instead of index. But it can be an int.

`type t`````
`include sig ... end`
`val t_of_sexp : Base.Sexp.t ‑> t`
`val sexp_of_t : t ‑> Base.Sexp.t`
`include Core_kernel.Comparable.S with type t := t`
`include Core_kernel__.Comparable_intf.S_common`
`include Base.Comparable.S`
`include Base__.Comparable_intf.Polymorphic_compare`
`include Base.Comparisons.Infix`
`type t`````
`val (>=) : t ‑> t ‑> bool`
`val (<=) : t ‑> t ‑> bool`
`val (=) : t ‑> t ‑> bool`
`val (>) : t ‑> t ‑> bool`
`val (<) : t ‑> t ‑> bool`
`val (<>) : t ‑> t ‑> bool`
`val equal : t ‑> t ‑> bool`
`val compare : t ‑> t ‑> int`

`compare t1 t2` returns 0 if `t1` is equal to `t2`, a negative integer if `t1` is less than `t2`, and a positive integer if `t1` is greater than `t2`.

`val min : t ‑> t ‑> t`
`val max : t ‑> t ‑> t`
`val ascending : t ‑> t ‑> int`

`ascending` is identical to `compare`. `descending x y = ascending y x`. These are intended to be mnemonic when used like `List.sort ~compare:ascending` and `List.sort ~cmp:descending`, since they cause the list to be sorted in ascending or descending order, respectively.

`val descending : t ‑> t ‑> int`
`val between : t ‑> low:t ‑> high:t ‑> bool`

`between t ~low ~high` means `low <= t <= high`

`val clamp_exn : t ‑> min:t ‑> max:t ‑> t`

`clamp_exn t ~min ~max` returns `t'`, the closest value to `t` such that `between t' ~low:min ~high:max` is true.

Raises if `not (min <= max)`.

`val clamp : t ‑> min:t ‑> max:t ‑> t Base.Or_error.t`
`include Base.Comparator.S with type t := t`
`type t`````
`type comparator_witness`````
`val comparator : (t, comparator_witness) Base.Comparator.comparator`
`include Base__.Comparable_intf.Validate with type t := t`
`type t`````
`val validate_lbound : min:t Base.Maybe_bound.t ‑> t Base.Validate.check`
`val validate_ubound : max:t Base.Maybe_bound.t ‑> t Base.Validate.check`
`val validate_bound : min:t Base.Maybe_bound.t ‑> max:t Base.Maybe_bound.t ‑> t Base.Validate.check`
`module Replace_polymorphic_compare : Core_kernel__.Comparable_intf.Polymorphic_compare with type t := t`
`module Map : Core_kernel.Map.S with type Key.t = t with type Key.comparator_witness = comparator_witness`
`module Set : Core_kernel.Set.S with type Elt.t = t with type Elt.comparator_witness = comparator_witness`
`val to_string : t ‑> string`