Module `Relude_Unit`

type t = unit;

let show: t => string;

module Show: BsBastet.Interface.SHOW with type Show.t = t;

include { ... };

let logShow: Show.t => unit;
let infoShow: Show.t => unit;
let warnShow: Show.t => unit;
let errorShow: Show.t => unit;

let eq: t => t => bool;

module Eq: BsBastet.Interface.EQ with type Eq.t = t;

include { ... };

let eqWithConversion: ('b => Eq.t) => Relude_Eq.eq('b);
let notEq: Relude_Eq.eq(Eq.t);
let eqInverted: Relude_Eq.eq(Eq.t);

module EqInverted: { ... };

module type EQ_BY_F = (A: { ... }) => { ... };

module EqBy: (A: { ... }) => { ... };

let compare: t => t => BsBastet.Interface.ordering;

module Ord: BsBastet.Interface.ORD with type Ord.t = t;

include { ... };

let compareWithConversion: ('b => Ord.t) => Relude_Ord.compare('b);
let compareReversed: Relude_Ord.compare(Ord.t);

module OrdReversed: { ... };

let compareAsInt: Ord.t => Ord.t => int;
let min: Ord.t => Ord.t => Ord.t;
let max: Ord.t => Ord.t => Ord.t;
let lessThan: Ord.t => Ord.t => bool;
let lt: Ord.t => Ord.t => bool;
let lessThanOrEq: Ord.t => Ord.t => bool;
let lte: Ord.t => Ord.t => bool;
let greaterThan: Ord.t => Ord.t => bool;
let gt: Ord.t => Ord.t => bool;
let greaterThanOrEq: Ord.t => Ord.t => bool;
let gte: Ord.t => Ord.t => bool;
let clamp: min:Ord.t => max:Ord.t => Ord.t => Ord.t;
let between: min:Ord.t => max:Ord.t => Ord.t => bool;

module OrdRingExtensions: (R: { ... }) => { ... };

module OrdNamed: { ... };

module type ORD_BY_F = (A: { ... }) => { ... };

module OrdBy: (A: { ... }) => { ... };

module Bounded: BsBastet.Interface.BOUNDED with type Bounded.t = unit;

include { ... };

module Enum: Relude_Interface.ENUM with type Enum.t = unit;

include { ... };

let fromToAsList: start:Enum.t => finish:Enum.t => list(Enum.t);
let upFromAsList: Enum.t => list(Enum.t);
let upFromIncludingAsList: Enum.t => list(Enum.t);
let downFromAsList: Enum.t => list(Enum.t);
let downFromIncludingAsList: Enum.t => list(Enum.t);

module BoundedEnum: Relude_Interface.BOUNDED_ENUM with type BoundedEnum.t = unit;

include { ... };

let fromThenToAsList: start:BoundedEnum.t => next:BoundedEnum.t => finish:BoundedEnum.t => list(BoundedEnum.t);