Data.Operator.Ord

class Ord1 f  where

The Ord1 typeclass of this module represents type constructors f that have an associated total ordering of values of type f a independent of any choice of a.

Unlike the Data.Ord.Ord1 typeclass of the 'Prelude' module [hereafter, qualified by the prefix "Prelude"], Ord1, defined here, is not generally equivalent to the Ord typeclass (also found in the 'Prelude' module).

For example, whereas both

compare (Cons 0 Nil) (Cons 1 Nil) == LT

and

Prelude.compare1 (Cons 0 Nil) (Cons 1 Nil) == LT

the definition found in this module gives the following:

compare1 (Cons 0 Nil) (Cons 1 Nil) == EQ

That is, the Int values in a value of List Int (and, more generally, the a values in any List a) have little relevance in determining the results of the compare1 function.

The instances of the Ord1 typeclass of this module are designed to emphasize the value-level effects of the type constructors themselves. In practice, this often means that an ordering is assigned to the type constructor's data constructors. The constructors Cons and Nil of List, for example, effectively constitute the 2-element total order Nil < Cons. The function compare1, then, in comparing any pair of lists, essentially compares the lists' head projections.

This interpretation of Ord1 exists in addition to Prelude.Ord1 because datatypes often have intrinsic (or designed) subgroupings, commonly distingished by data constructors, and a means to relate these different subgroupings can be useful. Either a b is a canonical example; it has two subclasses: a lower band of values of type a and an upper band of values of type b. This bifurcation is of particular significance to the Alt typeclass of the 'control' package, since the definition of its member alt (for Either) is almost exclusively determined by Either's Left and Right data constructors alone.

Incidentally, although all higher-order semigroups satisfy the type signature of alt, in practice, instances of Alternative tend to behave like totally ordered join-semilattices (usually with just two equivalence classes, one representing a valence reserved for errors or deficiency of some kind and the second comprising all remaining valences of a type constructor). These higher-order join-semilattices, furthermore, can be derived from the simpler concept of Ord1, since Alt's join operation (alt), for such cases, is equivalent to max1, an accompanying utility of Ord1.

Members

• compare1 :: forall a. f a -> f a -> Ordering

Instances

• Ord1 Array
• Ord1 CatList
• Ord1 CatQueue
• Ord1 (Const a)
• Ord1 First
• (Ord a) => Ord1 (Either a)
• (Ord a) => Ord1 (EitherR a)
• (Monad m, Ord1 m) => Ord1 (ExceptT a m)
• Ord1 Identity
• Ord1 Last
• Ord1 List
• Ord1 List
• Ord1 (Map k)
• Ord1 Maybe
• Ord1 NonEmptySet
• Ord1 Set
• Ord1 ZipList

between1 :: forall f a. Ord1 f => f a -> f a -> f a -> Boolean

clamp1 :: forall f a. Ord1 f => f a -> f a -> f a -> f a

comparing1 :: forall f b a. Ord1 f => (a -> f b) -> a -> a -> Ordering

greaterThan1 :: forall f a. Ord1 f => f a -> f a -> Boolean

Operator alias for Data.Operator.Ord.greaterThan1 (left-associative / precedence 4)

greaterThanOrEq1 :: forall f a. Ord1 f => f a -> f a -> Boolean

Operator alias for Data.Operator.Ord.greaterThanOrEq1 (left-associative / precedence 4)

lessThan1 :: forall f a. Ord1 f => f a -> f a -> Boolean

Operator alias for Data.Operator.Ord.lessThan1 (left-associative / precedence 4)

lessThanOrEq1 :: forall f a. Ord1 f => f a -> f a -> Boolean

Operator alias for Data.Operator.Ord.lessThanOrEq1 (left-associative / precedence 4)

max1 :: forall f a. Ord1 f => f a -> f a -> f a

min1 :: forall f a. Ord1 f => f a -> f a -> f a