base Data.Char GHC.Base, Cabal Distribution.Compat.Prelude.Internal, base-prelude BasePrelude, haskell-gi-base Data.GI.Base.ShortPrelude, rio RIO.Char, relude Relude.Base, universum Universum.Base, rebase Rebase.Prelude, brittany Language.Haskell.Brittany.Internal.Prelude, BNFC-meta Language.LBNF.Compiletime, unicode-data Unicode.Char

Lexicographic ordering of two vectors.

The Ord class is used for totally ordered datatypes.
Instances of Ord can be derived for any user-defined datatype
whose constituent types are in Ord. The declared order of the
constructors in the data declaration determines the ordering in
derived Ord instances. The Ordering datatype allows a
single comparison to determine the precise ordering of two objects.
Ord, as defined by the Haskell report, implements a total order
and has the following properties:
*not* require min and
max to return either of their arguments. The result is merely
required to *equal* one of the arguments in terms of (==).
Minimal complete definition: either compare or <=.
Using compare can be more efficient for complex types.

**Comparability**`x <= y || y <= x`= Trueif**Transitivity**`x <= y && y <= z`= True, then`x <= z`= True**Reflexivity**`x <= x`= Trueif**Antisymmetry**`x <= y && y <= x`= True, then`x == y`= True

`x >= y`=`y <= x``x < y`=`x <= y && x /= y``x > y`=`y < x``x < y`=`compare x y == LT``x > y`=`compare x y == GT``x == y`=`compare x y == EQ``min x y == if x <= y then x else y`= True`max x y == if x >= y then x else y`= True

The Ord class is used for totally ordered datatypes.
Instances of Ord can be derived for any user-defined datatype
whose constituent types are in Ord. The declared order of the
constructors in the data declaration determines the ordering in
derived Ord instances. The Ordering datatype allows a
single comparison to determine the precise ordering of two objects.
Ord, as defined by the Haskell report, implements a total order
and has the following properties:
*not* require min and
max to return either of their arguments. The result is merely
required to *equal* one of the arguments in terms of (==).
Minimal complete definition: either compare or <=.
Using compare can be more efficient for complex types.

**Comparability**`x <= y || y <= x`= Trueif**Transitivity**`x <= y && y <= z`= True, then`x <= z`= True**Reflexivity**`x <= x`= Trueif**Antisymmetry**`x <= y && y <= x`= True, then`x == y`= True

`x >= y`=`y <= x``x < y`=`x <= y && x /= y``x > y`=`y < x``x < y`=`compare x y == LT``x > y`=`compare x y == GT``x == y`=`compare x y == EQ``min x y == if x <= y then x else y`= True`max x y == if x >= y then x else y`= True

Cabal Distribution.Compat.Prelude.Internal, hedgehog Hedgehog.Internal.Prelude, base-prelude BasePrelude, rio RIO.Prelude.Types, classy-prelude ClassyPrelude, numeric-prelude NumericPrelude NumericPrelude.Base, relude Relude.Base, universum Universum.Base, foundation Foundation, basement Basement.Compat.Base Basement.Imports, clash-prelude Clash.HaskellPrelude, dimensional Numeric.Units.Dimensional.Prelude, ghc-lib-parser GHC.Prelude, rebase Rebase.Prelude, xmonad-contrib XMonad.Config.Prime

The Ord class is used for totally ordered datatypes.
Instances of Ord can be derived for any user-defined datatype
whose constituent types are in Ord. The declared order of the
constructors in the data declaration determines the ordering in
derived Ord instances. The Ordering datatype allows a
single comparison to determine the precise ordering of two objects.
The Haskell Report defines no laws for Ord. However,
<= is customarily expected to implement a non-strict partial
order and have the following properties:
*not* require min and
max to return either of their arguments. The result is merely
required to *equal* one of the arguments in terms of (==).
Minimal complete definition: either compare or <=.
Using compare can be more efficient for complex types.

if**Transitivity**`x <= y && y <= z`= True, then`x <= z`= True**Reflexivity**`x <= x`= Trueif**Antisymmetry**`x <= y && y <= x`= True, then`x == y`= True

`x >= y`=`y <= x``x < y`=`x <= y && x /= y``x > y`=`y < x``x < y`=`compare x y == LT``x > y`=`compare x y == GT``x == y`=`compare x y == EQ``min x y == if x <= y then x else y`= True`max x y == if x >= y then x else y`= True

Ord properties
You will need `TypeApplications` to use these.

The Ord class is used for totally ordered datatypes.
Instances of Ord can be derived for any user-defined datatype
whose constituent types are in Ord. The declared order of the
constructors in the data declaration determines the ordering in
derived Ord instances. The Ordering datatype allows a
single comparison to determine the precise ordering of two objects.
Minimal complete definition: either compare or <=.
Using compare can be more efficient for complex types.

Equality and ordering.
Note that equality doesn't really require a class, it can be defined
uniformly as TyEq.

This *optional* module is part of LeanCheck, a simple enumerative
property-based testing library.
Toy Eq and Ord instance for functions.
`12` value. Keep in mind that this value is
number of tests for *each* argument.
**Warning:** this is only intended to be used in testing modules.
Avoid importing this on modules that are used as libraries as there is
no way to unimport a typeclass instance.

instance (Listable a, Eq b) => Eq (a -> b) where (==) = areEqualFor 12

instance (Listable a, Ord b) => Ord (a -> b) where compare = compareFor 12This compares functions by testing them for up to 12 different values of each argument. Single argument functions are tested 12 times. Two argument functions are tested 144 times. Three argument functions are tested 1728 times. At each subsequent argument, number of tests and runtime increases 12-fold. To customize the number of tests, don't import this and use the above code changing the

The Ord class is used for totally ordered datatypes.
Instances of Ord can be derived for any user-defined datatype
whose constituent types are in Ord. The declared order of the
constructors in the data declaration determines the ordering in
derived Ord instances. The Ordering datatype allows a
single comparison to determine the precise ordering of two objects.
The Haskell Report defines no laws for Ord. However,
<= is customarily expected to implement a non-strict partial
order and have the following properties:

if**Transitivity**`x <= y && y <= z`= True, then`x <= z`= True**Reflexivity**`x <= x`= Trueif**Antisymmetry**`x <= y && y <= x`= True, then`x == y`= True

`x >= y`=`y <= x``x < y`=`x <= y && x /= y``x > y`=`y < x``x < y`=`compare x y == LT``x > y`=`compare x y == GT``x == y`=`compare x y == EQ``min x y == if x <= y then x else y`= True`max x y == if x >= y then x else y`= True

Ord properties
You will need `TypeApplications` to use these.

**Packages**- is:exact
- is:module
- base
- Cabal
- base-prelude
- haskell-gi-base
- rio
- relude
- universum
- rebase
- brittany
- BNFC-meta
- unicode-data
- text
- checkers
- sbv
- fixed-vector
- ghc-prim
- hedgehog
- classy-prelude
- numeric-prelude
- foundation
- basement
- clash-prelude
- dimensional
- ghc-lib-parser
- xmonad-contrib
- ghc
- text-show
- genvalidity-hspec
- rerebase
- basic-prelude
- first-class-families
- tfp
- leancheck
- prelude-compat
- llvm-hs-pure
- genvalidity-sydtest
- invertible
- texmath