Module

# Data.Ord

Package
purescript-prelude
Repository
purescript/purescript-prelude

### #OrdSource

``class (Eq a) <= Ord a  where``

The `Ord` type class represents types which support comparisons with a total order.

`Ord` instances should satisfy the laws of total orderings:

• Reflexivity: `a <= a`
• Antisymmetry: if `a <= b` and `b <= a` then `a = b`
• Transitivity: if `a <= b` and `b <= c` then `a <= c`

#### Members

• `compare :: a -> a -> Ordering`

#### Instances

• `Ord Boolean`
• `Ord Int`
• `Ord Number`
• `Ord String`
• `Ord Char`
• `Ord Unit`
• `Ord Void`
• `(Ord a) => Ord (Array a)`
• `Ord Ordering`
• `(RowToList row list, OrdRecord list row) => Ord (Record row)`

### #Ord1Source

``class (Eq1 f) <= Ord1 f  where``

The `Ord1` type class represents totally ordered type constructors.

#### Members

• `compare1 :: forall a. Ord a => f a -> f a -> Ordering`

#### Instances

• `Ord1 Array`

### #lessThanSource

``lessThan :: forall a. Ord a => a -> a -> Boolean``

Test whether one value is strictly less than another.

### #(<)Source

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

### #lessThanOrEqSource

``lessThanOrEq :: forall a. Ord a => a -> a -> Boolean``

Test whether one value is non-strictly less than another.

### #(<=)Source

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

### #greaterThanSource

``greaterThan :: forall a. Ord a => a -> a -> Boolean``

Test whether one value is strictly greater than another.

### #(>)Source

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

### #greaterThanOrEqSource

``greaterThanOrEq :: forall a. Ord a => a -> a -> Boolean``

Test whether one value is non-strictly greater than another.

### #(>=)Source

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

### #comparingSource

``comparing :: forall b a. Ord b => (a -> b) -> (a -> a -> Ordering)``

Compares two values by mapping them to a type with an `Ord` instance.

### #minSource

``min :: forall a. Ord a => a -> a -> a``

Take the minimum of two values. If they are considered equal, the first argument is chosen.

### #maxSource

``max :: forall a. Ord a => a -> a -> a``

Take the maximum of two values. If they are considered equal, the first argument is chosen.

### #clampSource

``clamp :: forall a. Ord a => a -> a -> a -> a``

Clamp a value between a minimum and a maximum. For example:

``````let f = clamp 0 10
f (-5) == 0
f 5    == 5
f 15   == 10
``````

### #betweenSource

``between :: forall a. Ord a => a -> a -> a -> Boolean``

Test whether a value is between a minimum and a maximum (inclusive). For example:

``````let f = between 0 10
f 0    == true
f (-5) == false
f 5    == true
f 10   == true
f 15   == false
``````

### #absSource

``abs :: forall a. Ord a => Ring a => a -> a``

The absolute value function. `abs x` is defined as ```if x >= zero then x else negate x```.

### #signumSource

``signum :: forall a. Ord a => Ring a => a -> a``

The sign function; always evaluates to either `one` or `negate one`. For any `x`, we should have `signum x * abs x == x`.

### #OrdRecordSource

``class (EqRecord rowlist row) <= OrdRecord rowlist row  where``

#### Members

• `compareRecord :: RLProxy rowlist -> Record row -> Record row -> Ordering`

#### Instances

• `OrdRecord Nil row`
• `(OrdRecord rowlistTail row, Cons key focus rowTail row, IsSymbol key, Ord focus) => OrdRecord (Cons key focus rowlistTail) row`

## Re-exports from Data.Ordering

### #OrderingSource

``data Ordering``

The `Ordering` data type represents the three possible outcomes of comparing two values:

`LT` - The first value is less than the second. `GT` - The first value is greater than the second. `EQ` - The first value is equal to the second.

• `LT`
• `GT`
• `EQ`

#### Instances

• `Eq Ordering`
• `Semigroup Ordering`
• `Show Ordering`