Relude.Enum

Returns all values of some Bounded Enum in ascending order.

>>> universe :: [Bool][False,True]

>>> universe @Ordering[LT,EQ,GT]

>>> data TrafficLight = Red | Blue | Green deriving (Show, Enum, Bounded)>>> universe :: [TrafficLight][Red,Blue,Green]

>>> data Singleton = Singleton deriving (Show, Enum, Bounded)>>> universe @Singleton[Singleton]

Like universe, but returns NonEmpty list of some enumeration

>>> universeNonEmpty :: NonEmpty BoolFalse :| [True]

>>> universeNonEmpty @OrderingLT :| [EQ,GT]

>>> data TrafficLight = Red | Blue | Green deriving (Show, Eq, Enum, Bounded)>>> universeNonEmpty :: NonEmpty TrafficLightRed :| [Blue,Green]

>>> data Singleton = Singleton deriving (Show, Eq, Enum, Bounded)>>> universeNonEmpty @SingletonSingleton :| []

inverseMap f creates a function that is the inverse of a given function f. It does so by constructing Map internally for each value f a. The implementation makes sure that the Map is constructed only once and then shared for every call.

Memory usage note: don't inverse functions that have types like Int as their input. In this case the created Map will have huge size.

The complexity of reversed mapping is \mathcal{O}(\log n).

Performance note: make sure to specialize monomorphic type of your functions that use inverseMap to avoid Map reconstruction.

One of the common inverseMap use-case is inverting the show or a show-like function.

>>> data Color = Red | Green | Blue deriving (Show, Enum, Bounded)>>> parse = inverseMap show :: String -> Maybe Color>>> parse "Red"Just Red>>> parse "Black"Nothing

Correctness note: inverseMap expects injective function as its argument, i.e. the function must map distinct arguments to distinct values.

Typical usage of this function looks like this:

data GhcVer
    = Ghc802
    | Ghc822
    | Ghc844
    | Ghc865
    | Ghc881
    deriving (Eq, Ord, Show, Enum, Bounded)

showGhcVer :: GhcVer -> Text
showGhcVer = \case
    Ghc802 -> "8.0.2"
    Ghc822 -> "8.2.2"
    Ghc844 -> "8.4.4"
    Ghc865 -> "8.6.5"
    Ghc881 -> "8.8.1"

parseGhcVer :: Text -> Maybe GhcVer
parseGhcVer = inverseMap showGhcVer

Class Enum defines operations on sequentially ordered types.

The enumFrom... methods are used in Haskell's translation of arithmetic sequences.

Instances of Enum may be derived for any enumeration type (types whose constructors have no fields). The nullary constructors are assumed to be numbered left-to-right by fromEnum from 0 through n-1. See Chapter 10 of the Haskell Report for more details.

For any type that is an instance of class Bounded as well as Enum, the following should hold:

• The calls succ maxBound and pred minBound should result in a runtime error.

• fromEnum and toEnum should give a runtime error if the result value is not representable in the result type. For example, toEnum 7 :: Bool is an error.

• enumFrom and enumFromThen should be defined with an implicit bound, thus:

   enumFrom     x   = enumFromTo     x maxBound
   enumFromThen x y = enumFromThenTo x y bound
     where
       bound | fromEnum y >= fromEnum x = maxBound
             | otherwise                = minBound

The Bounded class is used to name the upper and lower limits of a type. Ord is not a superclass of Bounded since types that are not totally ordered may also have upper and lower bounds.

The Bounded class may be derived for any enumeration type; minBound is the first constructor listed in the data declaration and maxBound is the last. Bounded may also be derived for single-constructor datatypes whose constituent types are in Bounded.