Data.Orphans

Exports orphan instances that mimic instances available in later versions of base. To use them, simply import Data.Orphans ().

Orphan instances

(Enum a, Bounded a, Eq a) => Enum (Down a)

Swaps succ and pred of the underlying type.

Methods

succ :: Down a -> Down a

pred :: Down a -> Down a

toEnum :: Int -> Down a

fromEnum :: Down a -> Int

enumFrom :: Down a -> [Down a]

enumFromThen :: Down a -> Down a -> [Down a]

enumFromTo :: Down a -> Down a -> [Down a]

enumFromThenTo :: Down a -> Down a -> Down a -> [Down a]

Functor ((,,,,) a b c d)

Methods

fmap :: (a0 -> b0) -> (a, b, c, d, a0) -> (a, b, c, d, b0)

(<$) :: a0 -> (a, b, c, d, b0) -> (a, b, c, d, a0)

Functor ((,,,,,) a b c d e)

Methods

fmap :: (a0 -> b0) -> (a, b, c, d, e, a0) -> (a, b, c, d, e, b0)

(<$) :: a0 -> (a, b, c, d, e, b0) -> (a, b, c, d, e, a0)

Bounded (f (g a)) => Bounded (Compose f g a)

Methods

minBound :: Compose f g a

maxBound :: Compose f g a

Enum (f (g a)) => Enum (Compose f g a)

Methods

succ :: Compose f g a -> Compose f g a

pred :: Compose f g a -> Compose f g a

toEnum :: Int -> Compose f g a

fromEnum :: Compose f g a -> Int

enumFrom :: Compose f g a -> [Compose f g a]

enumFromThen :: Compose f g a -> Compose f g a -> [Compose f g a]

enumFromTo :: Compose f g a -> Compose f g a -> [Compose f g a]

enumFromThenTo :: Compose f g a -> Compose f g a -> Compose f g a -> [Compose f g a]

Num (f (g a)) => Num (Compose f g a)

Methods

(+) :: Compose f g a -> Compose f g a -> Compose f g a

(-) :: Compose f g a -> Compose f g a -> Compose f g a

(*) :: Compose f g a -> Compose f g a -> Compose f g a

negate :: Compose f g a -> Compose f g a

abs :: Compose f g a -> Compose f g a

signum :: Compose f g a -> Compose f g a

fromInteger :: Integer -> Compose f g a

(Integral (f (g a)), Ord1 f, Ord1 g, Ord a) => Integral (Compose f g a)

Methods

quot :: Compose f g a -> Compose f g a -> Compose f g a

rem :: Compose f g a -> Compose f g a -> Compose f g a

div :: Compose f g a -> Compose f g a -> Compose f g a

mod :: Compose f g a -> Compose f g a -> Compose f g a

quotRem :: Compose f g a -> Compose f g a -> (Compose f g a, Compose f g a)

divMod :: Compose f g a -> Compose f g a -> (Compose f g a, Compose f g a)

toInteger :: Compose f g a -> Integer

(Real (f (g a)), Ord1 f, Ord1 g, Ord a) => Real (Compose f g a)

Methods

toRational :: Compose f g a -> Rational

Functor ((,,,,,,) a b c d e f)

Methods

fmap :: (a0 -> b0) -> (a, b, c, d, e, f, a0) -> (a, b, c, d, e, f, b0)

(<$) :: a0 -> (a, b, c, d, e, f, b0) -> (a, b, c, d, e, f, a0)