//@NO-IMPLICIT-PRELUDE
//! Definitions which gets implicit re-export in every file.

let { IO } = import! std.io.prim
let { Option } = import! std.types
let { Functor } = import! std.functor
let { Applicative, (*>), wrap } = import! std.applicative
let { Alternative } = import! std.alternative
let { Foldable } = import! std.foldable
let { Monad } = import! std.monad
let { Semigroup, append, (<>) } = import! std.semigroup
let { Monoid, empty } = import! std.monoid
let { Group } = import! std.group
let { Eq, Ord, Bool, Ordering, (==), (/=), (<), (<=), (>=), (>) } = import! std.cmp
let { Show, show } = import! std.show
let { Category, id, compose } = import! std.category
let { Num, (+), (-), (*), (/), negate } = import! std.num
let { Bool, not } = import! std.bool
let { Array } = import! std.array
let { (++) } = import! std.string
let { error } = import! std.prim
let { flat_map } = import! std.monad
let { (<|) } = import! std.function

{
    IO,

    Ordering,

    Semigroup,
    append,
    (<>),

    Monoid,
    empty,

    Group,

    Eq,
    (==),
    (/=),

    Ord,
    (<),
    (<=),
    (>=),
    (>),

    Category,
    id,
    compose,

    Functor,
    Applicative,
    Alternative,
    Monad,

    Num,
    (+),
    (-),
    (*),
    (/),
    negate,

    Show,
    show,

    Option,
    Bool,

    Array,

    (++),

    not,

    error,

    flat_map,

    (<|),
}