Data.Discrete

Documentation

class Discrete a where

A Discrete type is a set X with at least one element, along with two functions, succ :: X -> Maybe X and pred :: X -> Maybe X, such that all inhabitants of the set X can be constructed given at least a single element of the set and these two functions. The following must hold:

pred >=> succ >=> pred = pred

succ >=> pred >=> succ = succ

This means that Int is a discrete type, because given any x :: Int, one can construct any other Int with the following functions:

succ x = if x == maxBound then Nothing else Just (x + 1)

pred x = if x == minBound then Nothing else Just (x - 1)

This also means that something like Double is not a discrete type, because there are no such functions succ and pred that given any value of type Double can allow the construction of all values of type Double.

Discrete acts as a replacement for Enum. The motivation for Discrete is two-fold: firstly, totality of all typeclass instances, and secondly, that Enum is a typeclass that does too many things, and does them poorly. If succ or pred are called on maxBound or minBound, respectively, the result will be Nothing.

Minimal complete definition

pred, succ

Methods

succ :: a -> Maybe a

pred :: a -> Maybe a

Instances

Discrete Bool

Defined in Data.Discrete

Methods

succ :: Bool -> Maybe Bool

pred :: Bool -> Maybe Bool

Discrete Char

Defined in Data.Discrete

Methods

succ :: Char -> Maybe Char

pred :: Char -> Maybe Char

Discrete Int

Defined in Data.Discrete

Methods

succ :: Int -> Maybe Int

pred :: Int -> Maybe Int

Discrete Int8

Defined in Data.Discrete

Methods

succ :: Int8 -> Maybe Int8

pred :: Int8 -> Maybe Int8

Discrete Int16

Defined in Data.Discrete

Methods

succ :: Int16 -> Maybe Int16

pred :: Int16 -> Maybe Int16

Discrete Int32

Defined in Data.Discrete

Methods

succ :: Int32 -> Maybe Int32

pred :: Int32 -> Maybe Int32

Discrete Int64

Defined in Data.Discrete

Methods

succ :: Int64 -> Maybe Int64

pred :: Int64 -> Maybe Int64

Discrete Integer

Defined in Data.Discrete

Methods

succ :: Integer -> Maybe Integer

pred :: Integer -> Maybe Integer

Discrete Ordering

Defined in Data.Discrete

Methods

succ :: Ordering -> Maybe Ordering

pred :: Ordering -> Maybe Ordering

Discrete Word

Defined in Data.Discrete

Methods

succ :: Word -> Maybe Word

pred :: Word -> Maybe Word

Discrete Word8

Defined in Data.Discrete

Methods

succ :: Word8 -> Maybe Word8

pred :: Word8 -> Maybe Word8

Discrete Word16

Defined in Data.Discrete

Methods

succ :: Word16 -> Maybe Word16

pred :: Word16 -> Maybe Word16

Discrete Word32

Defined in Data.Discrete

Methods

succ :: Word32 -> Maybe Word32

pred :: Word32 -> Maybe Word32

Discrete Word64

Defined in Data.Discrete

Methods

succ :: Word64 -> Maybe Word64

pred :: Word64 -> Maybe Word64

Discrete ()

Defined in Data.Discrete

Methods

succ :: () -> Maybe ()

pred :: () -> Maybe ()

Discrete a => Discrete (Maybe a)

Defined in Data.Discrete

Methods

succ :: Maybe a -> Maybe (Maybe a)

pred :: Maybe a -> Maybe (Maybe a)

Integral a => Discrete (Ratio a)

Defined in Data.Discrete

Methods

succ :: Ratio a -> Maybe (Ratio a)

pred :: Ratio a -> Maybe (Ratio a)

Discrete a => Discrete (Identity a)

Defined in Data.Discrete

Methods

succ :: Identity a -> Maybe (Identity a)

pred :: Identity a -> Maybe (Identity a)

(Bounded a, Bounded b, Discrete a, Discrete b) => Discrete (Either a b)

Defined in Data.Discrete

Methods

succ :: Either a b -> Maybe (Either a b)

pred :: Either a b -> Maybe (Either a b)

(Bounded b, Discrete a, Discrete b) => Discrete (a, b)

Defined in Data.Discrete

Methods

succ :: (a, b) -> Maybe (a, b)

pred :: (a, b) -> Maybe (a, b)

Discrete a => Discrete (Const a b)

Defined in Data.Discrete

Methods

succ :: Const a b -> Maybe (Const a b)

pred :: Const a b -> Maybe (Const a b)

Discrete (f a) => Discrete (Alt f a)

Defined in Data.Discrete

Methods

succ :: Alt f a -> Maybe (Alt f a)

pred :: Alt f a -> Maybe (Alt f a)

a ~ b => Discrete (a :~: b)

Defined in Data.Discrete

Methods

succ :: (a :~: b) -> Maybe (a :~: b)

pred :: (a :~: b) -> Maybe (a :~: b)

a ~~ b => Discrete (a :~~: b)

Defined in Data.Discrete

Methods

succ :: (a :~~: b) -> Maybe (a :~~: b)

pred :: (a :~~: b) -> Maybe (a :~~: b)