GHC.Exts

GHC Extensions: this is the Approved Way to get at GHC-specific extensions.

Note: no other base module should import this module.

Representations of some basic types

data Int :: *

A fixed-precision integer type with at least the range [-2^29 .. 2^29-1]. The exact range for a given implementation can be determined by using minBound and maxBound from the Bounded class.

Constructors

I# Int#

Instances

Bounded Int

Since: 2.1

Methods

minBound :: Int

maxBound :: Int

Enum Int

Since: 2.1

Methods

succ :: Int -> Int

pred :: Int -> Int

toEnum :: Int -> Int

fromEnum :: Int -> Int

enumFrom :: Int -> [Int]

enumFromThen :: Int -> Int -> [Int]

enumFromTo :: Int -> Int -> [Int]

enumFromThenTo :: Int -> Int -> Int -> [Int]

Eq Int

Methods

(==) :: Int -> Int -> Bool

(/=) :: Int -> Int -> Bool

Integral Int

Since: 2.0.1

Methods

quot :: Int -> Int -> Int

rem :: Int -> Int -> Int

div :: Int -> Int -> Int

mod :: Int -> Int -> Int

quotRem :: Int -> Int -> (Int, Int)

divMod :: Int -> Int -> (Int, Int)

toInteger :: Int -> Integer

Data Int

Since: 4.0.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int -> c Int

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int

toConstr :: Int -> Constr

dataTypeOf :: Int -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Int)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int)

gmapT :: (forall b. Data b => b -> b) -> Int -> Int

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int -> r

gmapQ :: (forall d. Data d => d -> u) -> Int -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Int -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int -> m Int

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int -> m Int

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int -> m Int

Num Int

Since: 2.1

Methods

(+) :: Int -> Int -> Int

(-) :: Int -> Int -> Int

(*) :: Int -> Int -> Int

negate :: Int -> Int

abs :: Int -> Int

signum :: Int -> Int

fromInteger :: Integer -> Int

Ord Int

Methods

compare :: Int -> Int -> Ordering

(<) :: Int -> Int -> Bool

(<=) :: Int -> Int -> Bool

(>) :: Int -> Int -> Bool

(>=) :: Int -> Int -> Bool

max :: Int -> Int -> Int

min :: Int -> Int -> Int

Read Int

Since: 2.1

Methods

readsPrec :: Int -> ReadS Int

readList :: ReadS [Int]

readPrec :: ReadPrec Int

readListPrec :: ReadPrec [Int]

Real Int

Since: 2.0.1

Methods

toRational :: Int -> Rational

Show Int

Since: 2.1

Methods

showsPrec :: Int -> Int -> ShowS

show :: Int -> String

showList :: [Int] -> ShowS

Ix Int

Since: 2.1

Methods

range :: (Int, Int) -> [Int]

index :: (Int, Int) -> Int -> Int

unsafeIndex :: (Int, Int) -> Int -> Int

inRange :: (Int, Int) -> Int -> Bool

rangeSize :: (Int, Int) -> Int

unsafeRangeSize :: (Int, Int) -> Int

FiniteBits Int

Since: 4.6.0.0

Methods

finiteBitSize :: Int -> Int

countLeadingZeros :: Int -> Int

countTrailingZeros :: Int -> Int

Bits Int

Since: 2.1

Methods

(.&.) :: Int -> Int -> Int

(.|.) :: Int -> Int -> Int

xor :: Int -> Int -> Int

complement :: Int -> Int

shift :: Int -> Int -> Int

rotate :: Int -> Int -> Int

zeroBits :: Int

bit :: Int -> Int

setBit :: Int -> Int -> Int

clearBit :: Int -> Int -> Int

complementBit :: Int -> Int -> Int

testBit :: Int -> Int -> Bool

bitSizeMaybe :: Int -> Maybe Int

bitSize :: Int -> Int

isSigned :: Int -> Bool

shiftL :: Int -> Int -> Int

unsafeShiftL :: Int -> Int -> Int

shiftR :: Int -> Int -> Int

unsafeShiftR :: Int -> Int -> Int

rotateL :: Int -> Int -> Int

rotateR :: Int -> Int -> Int

popCount :: Int -> Int

Storable Int

Since: 2.1

Methods

sizeOf :: Int -> Int

alignment :: Int -> Int

peekElemOff :: Ptr Int -> Int -> IO Int

pokeElemOff :: Ptr Int -> Int -> Int -> IO ()

peekByteOff :: Ptr b -> Int -> IO Int

pokeByteOff :: Ptr b -> Int -> Int -> IO ()

peek :: Ptr Int -> IO Int

poke :: Ptr Int -> Int -> IO ()

PrintfArg Int

Since: 2.1

Methods

formatArg :: Int -> FieldFormatter

parseFormat :: Int -> ModifierParser

Generic1 k (URec k Int)

Associated Types

type Rep1 (URec k Int) (f :: URec k Int -> *) :: k -> *

Methods

from1 :: f a -> Rep1 (URec k Int) f a

to1 :: Rep1 (URec k Int) f a -> f a

Functor (URec * Int)

Methods

fmap :: (a -> b) -> URec * Int a -> URec * Int b

(<$) :: a -> URec * Int b -> URec * Int a

Foldable (URec * Int)

Methods

fold :: Monoid m => URec * Int m -> m

foldMap :: Monoid m => (a -> m) -> URec * Int a -> m

foldr :: (a -> b -> b) -> b -> URec * Int a -> b

foldr' :: (a -> b -> b) -> b -> URec * Int a -> b

foldl :: (b -> a -> b) -> b -> URec * Int a -> b

foldl' :: (b -> a -> b) -> b -> URec * Int a -> b

foldr1 :: (a -> a -> a) -> URec * Int a -> a

foldl1 :: (a -> a -> a) -> URec * Int a -> a

toList :: URec * Int a -> [a]

null :: URec * Int a -> Bool

length :: URec * Int a -> Int

elem :: Eq a => a -> URec * Int a -> Bool

maximum :: Ord a => URec * Int a -> a

minimum :: Ord a => URec * Int a -> a

sum :: Num a => URec * Int a -> a

product :: Num a => URec * Int a -> a

Traversable (URec * Int)

Methods

traverse :: Applicative f => (a -> f b) -> URec * Int a -> f (URec * Int b)

sequenceA :: Applicative f => URec * Int (f a) -> f (URec * Int a)

mapM :: Monad m => (a -> m b) -> URec * Int a -> m (URec * Int b)

sequence :: Monad m => URec * Int (m a) -> m (URec * Int a)

Eq (URec k Int p)

Methods

(==) :: URec k Int p -> URec k Int p -> Bool

(/=) :: URec k Int p -> URec k Int p -> Bool

Ord (URec k Int p)

Methods

compare :: URec k Int p -> URec k Int p -> Ordering

(<) :: URec k Int p -> URec k Int p -> Bool

(<=) :: URec k Int p -> URec k Int p -> Bool

(>) :: URec k Int p -> URec k Int p -> Bool

(>=) :: URec k Int p -> URec k Int p -> Bool

max :: URec k Int p -> URec k Int p -> URec k Int p

min :: URec k Int p -> URec k Int p -> URec k Int p

Show (URec k Int p)

Methods

showsPrec :: Int -> URec k Int p -> ShowS

show :: URec k Int p -> String

showList :: [URec k Int p] -> ShowS

Generic (URec k Int p)

Associated Types

type Rep (URec k Int p) :: * -> *

Methods

from :: URec k Int p -> Rep (URec k Int p) x

to :: Rep (URec k Int p) x -> URec k Int p

data URec k Int

Used for marking occurrences of Int#

Since: 4.9.0.0

data URec k Int = UInt {

• uInt# :: Int#

}

type Rep1 k (URec k Int)

type Rep1 k (URec k Int) = D1 k (MetaData "URec" "GHC.Generics" "base" False) (C1 k (MetaCons "UInt" PrefixI True) (S1 k (MetaSel (Just Symbol "uInt#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UInt k)))

type Rep (URec k Int p)

type Rep (URec k Int p) = D1 * (MetaData "URec" "GHC.Generics" "base" False) (C1 * (MetaCons "UInt" PrefixI True) (S1 * (MetaSel (Just Symbol "uInt#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UInt *)))

data Word :: *

A Word is an unsigned integral type, with the same size as Int.

Constructors

W# Word#

Instances

Bounded Word

Since: 2.1

Methods

minBound :: Word

maxBound :: Word

Enum Word

Since: 2.1

Methods

succ :: Word -> Word

pred :: Word -> Word

toEnum :: Int -> Word

fromEnum :: Word -> Int

enumFrom :: Word -> [Word]

enumFromThen :: Word -> Word -> [Word]

enumFromTo :: Word -> Word -> [Word]

enumFromThenTo :: Word -> Word -> Word -> [Word]

Eq Word

Methods

(==) :: Word -> Word -> Bool

(/=) :: Word -> Word -> Bool

Integral Word

Since: 2.1

Methods

quot :: Word -> Word -> Word

rem :: Word -> Word -> Word

div :: Word -> Word -> Word

mod :: Word -> Word -> Word

quotRem :: Word -> Word -> (Word, Word)

divMod :: Word -> Word -> (Word, Word)

toInteger :: Word -> Integer

Data Word

Since: 4.0.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word -> c Word

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word

toConstr :: Word -> Constr

dataTypeOf :: Word -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Word)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word)

gmapT :: (forall b. Data b => b -> b) -> Word -> Word

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word -> r

gmapQ :: (forall d. Data d => d -> u) -> Word -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Word -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word -> m Word

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word -> m Word

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word -> m Word

Num Word

Since: 2.1

Methods

(+) :: Word -> Word -> Word

(-) :: Word -> Word -> Word

(*) :: Word -> Word -> Word

negate :: Word -> Word

abs :: Word -> Word

signum :: Word -> Word

fromInteger :: Integer -> Word

Ord Word

Methods

compare :: Word -> Word -> Ordering

(<) :: Word -> Word -> Bool

(<=) :: Word -> Word -> Bool

(>) :: Word -> Word -> Bool

(>=) :: Word -> Word -> Bool

max :: Word -> Word -> Word

min :: Word -> Word -> Word

Read Word

Since: 4.5.0.0

Methods

readsPrec :: Int -> ReadS Word

readList :: ReadS [Word]

readPrec :: ReadPrec Word

readListPrec :: ReadPrec [Word]

Real Word

Since: 2.1

Methods

toRational :: Word -> Rational

Show Word

Since: 2.1

Methods

showsPrec :: Int -> Word -> ShowS

show :: Word -> String

showList :: [Word] -> ShowS

Ix Word

Since: 4.6.0.0

Methods

range :: (Word, Word) -> [Word]

index :: (Word, Word) -> Word -> Int

unsafeIndex :: (Word, Word) -> Word -> Int

inRange :: (Word, Word) -> Word -> Bool

rangeSize :: (Word, Word) -> Int

unsafeRangeSize :: (Word, Word) -> Int

FiniteBits Word

Since: 4.6.0.0

Methods

finiteBitSize :: Word -> Int

countLeadingZeros :: Word -> Int

countTrailingZeros :: Word -> Int

Bits Word

Since: 2.1

Methods

(.&.) :: Word -> Word -> Word

(.|.) :: Word -> Word -> Word

xor :: Word -> Word -> Word

complement :: Word -> Word

shift :: Word -> Int -> Word

rotate :: Word -> Int -> Word

zeroBits :: Word

bit :: Int -> Word

setBit :: Word -> Int -> Word

clearBit :: Word -> Int -> Word

complementBit :: Word -> Int -> Word

testBit :: Word -> Int -> Bool

bitSizeMaybe :: Word -> Maybe Int

bitSize :: Word -> Int

isSigned :: Word -> Bool

shiftL :: Word -> Int -> Word

unsafeShiftL :: Word -> Int -> Word

shiftR :: Word -> Int -> Word

unsafeShiftR :: Word -> Int -> Word

rotateL :: Word -> Int -> Word

rotateR :: Word -> Int -> Word

popCount :: Word -> Int

Storable Word

Since: 2.1

Methods

sizeOf :: Word -> Int

alignment :: Word -> Int

peekElemOff :: Ptr Word -> Int -> IO Word

pokeElemOff :: Ptr Word -> Int -> Word -> IO ()

peekByteOff :: Ptr b -> Int -> IO Word

pokeByteOff :: Ptr b -> Int -> Word -> IO ()

peek :: Ptr Word -> IO Word

poke :: Ptr Word -> Word -> IO ()

PrintfArg Word

Since: 2.1

Methods

formatArg :: Word -> FieldFormatter

parseFormat :: Word -> ModifierParser

Generic1 k (URec k Word)

Associated Types

type Rep1 (URec k Word) (f :: URec k Word -> *) :: k -> *

Methods

from1 :: f a -> Rep1 (URec k Word) f a

to1 :: Rep1 (URec k Word) f a -> f a

Functor (URec * Word)

Methods

fmap :: (a -> b) -> URec * Word a -> URec * Word b

(<$) :: a -> URec * Word b -> URec * Word a

Foldable (URec * Word)

Methods

fold :: Monoid m => URec * Word m -> m

foldMap :: Monoid m => (a -> m) -> URec * Word a -> m

foldr :: (a -> b -> b) -> b -> URec * Word a -> b

foldr' :: (a -> b -> b) -> b -> URec * Word a -> b

foldl :: (b -> a -> b) -> b -> URec * Word a -> b

foldl' :: (b -> a -> b) -> b -> URec * Word a -> b

foldr1 :: (a -> a -> a) -> URec * Word a -> a

foldl1 :: (a -> a -> a) -> URec * Word a -> a

toList :: URec * Word a -> [a]

null :: URec * Word a -> Bool

length :: URec * Word a -> Int

elem :: Eq a => a -> URec * Word a -> Bool

maximum :: Ord a => URec * Word a -> a

minimum :: Ord a => URec * Word a -> a

sum :: Num a => URec * Word a -> a

product :: Num a => URec * Word a -> a

Traversable (URec * Word)

Methods

traverse :: Applicative f => (a -> f b) -> URec * Word a -> f (URec * Word b)

sequenceA :: Applicative f => URec * Word (f a) -> f (URec * Word a)

mapM :: Monad m => (a -> m b) -> URec * Word a -> m (URec * Word b)

sequence :: Monad m => URec * Word (m a) -> m (URec * Word a)

Eq (URec k Word p)

Methods

(==) :: URec k Word p -> URec k Word p -> Bool

(/=) :: URec k Word p -> URec k Word p -> Bool

Ord (URec k Word p)

Methods

compare :: URec k Word p -> URec k Word p -> Ordering

(<) :: URec k Word p -> URec k Word p -> Bool

(<=) :: URec k Word p -> URec k Word p -> Bool

(>) :: URec k Word p -> URec k Word p -> Bool

(>=) :: URec k Word p -> URec k Word p -> Bool

max :: URec k Word p -> URec k Word p -> URec k Word p

min :: URec k Word p -> URec k Word p -> URec k Word p

Show (URec k Word p)

Methods

showsPrec :: Int -> URec k Word p -> ShowS

show :: URec k Word p -> String

showList :: [URec k Word p] -> ShowS

Generic (URec k Word p)

Associated Types

type Rep (URec k Word p) :: * -> *

Methods

from :: URec k Word p -> Rep (URec k Word p) x

to :: Rep (URec k Word p) x -> URec k Word p

data URec k Word

Used for marking occurrences of Word#

Since: 4.9.0.0

data URec k Word = UWord {

• uWord# :: Word#

}

type Rep1 k (URec k Word)

type Rep1 k (URec k Word) = D1 k (MetaData "URec" "GHC.Generics" "base" False) (C1 k (MetaCons "UWord" PrefixI True) (S1 k (MetaSel (Just Symbol "uWord#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UWord k)))

type Rep (URec k Word p)

type Rep (URec k Word p) = D1 * (MetaData "URec" "GHC.Generics" "base" False) (C1 * (MetaCons "UWord" PrefixI True) (S1 * (MetaSel (Just Symbol "uWord#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UWord *)))

data Float :: *

Single-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE single-precision type.

Constructors

F# Float#

Instances

Eq Float

Methods

(==) :: Float -> Float -> Bool

(/=) :: Float -> Float -> Bool

Floating Float

Since: 2.1

Methods

pi :: Float

exp :: Float -> Float

log :: Float -> Float

sqrt :: Float -> Float

(**) :: Float -> Float -> Float

logBase :: Float -> Float -> Float

sin :: Float -> Float

cos :: Float -> Float

tan :: Float -> Float

asin :: Float -> Float

acos :: Float -> Float

atan :: Float -> Float

sinh :: Float -> Float

cosh :: Float -> Float

tanh :: Float -> Float

asinh :: Float -> Float

acosh :: Float -> Float

atanh :: Float -> Float

log1p :: Float -> Float

expm1 :: Float -> Float

log1pexp :: Float -> Float

log1mexp :: Float -> Float

Data Float

Since: 4.0.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Float -> c Float

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Float

toConstr :: Float -> Constr

dataTypeOf :: Float -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Float)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Float)

gmapT :: (forall b. Data b => b -> b) -> Float -> Float

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Float -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Float -> r

gmapQ :: (forall d. Data d => d -> u) -> Float -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Float -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Float -> m Float

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Float -> m Float

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Float -> m Float

Ord Float

Methods

compare :: Float -> Float -> Ordering

(<) :: Float -> Float -> Bool

(<=) :: Float -> Float -> Bool

(>) :: Float -> Float -> Bool

(>=) :: Float -> Float -> Bool

max :: Float -> Float -> Float

min :: Float -> Float -> Float

Read Float

Since: 2.1

Methods

readsPrec :: Int -> ReadS Float

readList :: ReadS [Float]

readPrec :: ReadPrec Float

readListPrec :: ReadPrec [Float]

RealFloat Float

Since: 2.1

Methods

floatRadix :: Float -> Integer

floatDigits :: Float -> Int

floatRange :: Float -> (Int, Int)

decodeFloat :: Float -> (Integer, Int)

encodeFloat :: Integer -> Int -> Float

exponent :: Float -> Int

significand :: Float -> Float

scaleFloat :: Int -> Float -> Float

isNaN :: Float -> Bool

isInfinite :: Float -> Bool

isDenormalized :: Float -> Bool

isNegativeZero :: Float -> Bool

isIEEE :: Float -> Bool

atan2 :: Float -> Float -> Float

Storable Float

Since: 2.1

Methods

sizeOf :: Float -> Int

alignment :: Float -> Int

peekElemOff :: Ptr Float -> Int -> IO Float

pokeElemOff :: Ptr Float -> Int -> Float -> IO ()

peekByteOff :: Ptr b -> Int -> IO Float

pokeByteOff :: Ptr b -> Int -> Float -> IO ()

peek :: Ptr Float -> IO Float

poke :: Ptr Float -> Float -> IO ()

PrintfArg Float

Since: 2.1

Methods

formatArg :: Float -> FieldFormatter

parseFormat :: Float -> ModifierParser

Generic1 k (URec k Float)

Associated Types

type Rep1 (URec k Float) (f :: URec k Float -> *) :: k -> *

Methods

from1 :: f a -> Rep1 (URec k Float) f a

to1 :: Rep1 (URec k Float) f a -> f a

Functor (URec * Float)

Methods

fmap :: (a -> b) -> URec * Float a -> URec * Float b

(<$) :: a -> URec * Float b -> URec * Float a

Foldable (URec * Float)

Methods

fold :: Monoid m => URec * Float m -> m

foldMap :: Monoid m => (a -> m) -> URec * Float a -> m

foldr :: (a -> b -> b) -> b -> URec * Float a -> b

foldr' :: (a -> b -> b) -> b -> URec * Float a -> b

foldl :: (b -> a -> b) -> b -> URec * Float a -> b

foldl' :: (b -> a -> b) -> b -> URec * Float a -> b

foldr1 :: (a -> a -> a) -> URec * Float a -> a

foldl1 :: (a -> a -> a) -> URec * Float a -> a

toList :: URec * Float a -> [a]

null :: URec * Float a -> Bool

length :: URec * Float a -> Int

elem :: Eq a => a -> URec * Float a -> Bool

maximum :: Ord a => URec * Float a -> a

minimum :: Ord a => URec * Float a -> a

sum :: Num a => URec * Float a -> a

product :: Num a => URec * Float a -> a

Traversable (URec * Float)

Methods

traverse :: Applicative f => (a -> f b) -> URec * Float a -> f (URec * Float b)

sequenceA :: Applicative f => URec * Float (f a) -> f (URec * Float a)

mapM :: Monad m => (a -> m b) -> URec * Float a -> m (URec * Float b)

sequence :: Monad m => URec * Float (m a) -> m (URec * Float a)

Eq (URec k Float p)

Methods

(==) :: URec k Float p -> URec k Float p -> Bool

(/=) :: URec k Float p -> URec k Float p -> Bool

Ord (URec k Float p)

Methods

compare :: URec k Float p -> URec k Float p -> Ordering

(<) :: URec k Float p -> URec k Float p -> Bool

(<=) :: URec k Float p -> URec k Float p -> Bool

(>) :: URec k Float p -> URec k Float p -> Bool

(>=) :: URec k Float p -> URec k Float p -> Bool

max :: URec k Float p -> URec k Float p -> URec k Float p

min :: URec k Float p -> URec k Float p -> URec k Float p

Show (URec k Float p)

Methods

showsPrec :: Int -> URec k Float p -> ShowS

show :: URec k Float p -> String

showList :: [URec k Float p] -> ShowS

Generic (URec k Float p)

Associated Types

type Rep (URec k Float p) :: * -> *

Methods

from :: URec k Float p -> Rep (URec k Float p) x

to :: Rep (URec k Float p) x -> URec k Float p

data URec k Float

Used for marking occurrences of Float#

Since: 4.9.0.0

data URec k Float = UFloat {

• uFloat# :: Float#

}

type Rep1 k (URec k Float)

type Rep1 k (URec k Float) = D1 k (MetaData "URec" "GHC.Generics" "base" False) (C1 k (MetaCons "UFloat" PrefixI True) (S1 k (MetaSel (Just Symbol "uFloat#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UFloat k)))

type Rep (URec k Float p)

type Rep (URec k Float p) = D1 * (MetaData "URec" "GHC.Generics" "base" False) (C1 * (MetaCons "UFloat" PrefixI True) (S1 * (MetaSel (Just Symbol "uFloat#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UFloat *)))

data Double :: *

Double-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE double-precision type.

Constructors

D# Double#

Instances

Eq Double

Methods

(==) :: Double -> Double -> Bool

(/=) :: Double -> Double -> Bool

Floating Double

Since: 2.1

Methods

pi :: Double

exp :: Double -> Double

log :: Double -> Double

sqrt :: Double -> Double

(**) :: Double -> Double -> Double

logBase :: Double -> Double -> Double

sin :: Double -> Double

cos :: Double -> Double

tan :: Double -> Double

asin :: Double -> Double

acos :: Double -> Double

atan :: Double -> Double

sinh :: Double -> Double

cosh :: Double -> Double

tanh :: Double -> Double

asinh :: Double -> Double

acosh :: Double -> Double

atanh :: Double -> Double

log1p :: Double -> Double

expm1 :: Double -> Double

log1pexp :: Double -> Double

log1mexp :: Double -> Double

Data Double

Since: 4.0.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Double -> c Double

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Double

toConstr :: Double -> Constr

dataTypeOf :: Double -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Double)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Double)

gmapT :: (forall b. Data b => b -> b) -> Double -> Double

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Double -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Double -> r

gmapQ :: (forall d. Data d => d -> u) -> Double -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Double -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Double -> m Double

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Double -> m Double

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Double -> m Double

Ord Double

Methods

compare :: Double -> Double -> Ordering

(<) :: Double -> Double -> Bool

(<=) :: Double -> Double -> Bool

(>) :: Double -> Double -> Bool

(>=) :: Double -> Double -> Bool

max :: Double -> Double -> Double

min :: Double -> Double -> Double

Read Double

Since: 2.1

Methods

readsPrec :: Int -> ReadS Double

readList :: ReadS [Double]

readPrec :: ReadPrec Double

readListPrec :: ReadPrec [Double]

RealFloat Double

Since: 2.1

Methods

floatRadix :: Double -> Integer

floatDigits :: Double -> Int

floatRange :: Double -> (Int, Int)

decodeFloat :: Double -> (Integer, Int)

encodeFloat :: Integer -> Int -> Double

exponent :: Double -> Int

significand :: Double -> Double

scaleFloat :: Int -> Double -> Double

isNaN :: Double -> Bool

isInfinite :: Double -> Bool

isDenormalized :: Double -> Bool

isNegativeZero :: Double -> Bool

isIEEE :: Double -> Bool

atan2 :: Double -> Double -> Double

Storable Double

Since: 2.1

Methods

sizeOf :: Double -> Int

alignment :: Double -> Int

peekElemOff :: Ptr Double -> Int -> IO Double

pokeElemOff :: Ptr Double -> Int -> Double -> IO ()

peekByteOff :: Ptr b -> Int -> IO Double

pokeByteOff :: Ptr b -> Int -> Double -> IO ()

peek :: Ptr Double -> IO Double

poke :: Ptr Double -> Double -> IO ()

PrintfArg Double

Since: 2.1

Methods

formatArg :: Double -> FieldFormatter

parseFormat :: Double -> ModifierParser

Generic1 k (URec k Double)

Associated Types

type Rep1 (URec k Double) (f :: URec k Double -> *) :: k -> *

Methods

from1 :: f a -> Rep1 (URec k Double) f a

to1 :: Rep1 (URec k Double) f a -> f a

Functor (URec * Double)

Methods

fmap :: (a -> b) -> URec * Double a -> URec * Double b

(<$) :: a -> URec * Double b -> URec * Double a

Foldable (URec * Double)

Methods

fold :: Monoid m => URec * Double m -> m

foldMap :: Monoid m => (a -> m) -> URec * Double a -> m

foldr :: (a -> b -> b) -> b -> URec * Double a -> b

foldr' :: (a -> b -> b) -> b -> URec * Double a -> b

foldl :: (b -> a -> b) -> b -> URec * Double a -> b

foldl' :: (b -> a -> b) -> b -> URec * Double a -> b

foldr1 :: (a -> a -> a) -> URec * Double a -> a

foldl1 :: (a -> a -> a) -> URec * Double a -> a

toList :: URec * Double a -> [a]

null :: URec * Double a -> Bool

length :: URec * Double a -> Int

elem :: Eq a => a -> URec * Double a -> Bool

maximum :: Ord a => URec * Double a -> a

minimum :: Ord a => URec * Double a -> a

sum :: Num a => URec * Double a -> a

product :: Num a => URec * Double a -> a

Traversable (URec * Double)

Methods

traverse :: Applicative f => (a -> f b) -> URec * Double a -> f (URec * Double b)

sequenceA :: Applicative f => URec * Double (f a) -> f (URec * Double a)

mapM :: Monad m => (a -> m b) -> URec * Double a -> m (URec * Double b)

sequence :: Monad m => URec * Double (m a) -> m (URec * Double a)

Eq (URec k Double p)

Methods

(==) :: URec k Double p -> URec k Double p -> Bool

(/=) :: URec k Double p -> URec k Double p -> Bool

Ord (URec k Double p)

Methods

compare :: URec k Double p -> URec k Double p -> Ordering

(<) :: URec k Double p -> URec k Double p -> Bool

(<=) :: URec k Double p -> URec k Double p -> Bool

(>) :: URec k Double p -> URec k Double p -> Bool

(>=) :: URec k Double p -> URec k Double p -> Bool

max :: URec k Double p -> URec k Double p -> URec k Double p

min :: URec k Double p -> URec k Double p -> URec k Double p

Show (URec k Double p)

Methods

showsPrec :: Int -> URec k Double p -> ShowS

show :: URec k Double p -> String

showList :: [URec k Double p] -> ShowS

Generic (URec k Double p)

Associated Types

type Rep (URec k Double p) :: * -> *

Methods

from :: URec k Double p -> Rep (URec k Double p) x

to :: Rep (URec k Double p) x -> URec k Double p

data URec k Double

Used for marking occurrences of Double#

Since: 4.9.0.0

data URec k Double = UDouble {

• uDouble# :: Double#

}

type Rep1 k (URec k Double)

type Rep1 k (URec k Double) = D1 k (MetaData "URec" "GHC.Generics" "base" False) (C1 k (MetaCons "UDouble" PrefixI True) (S1 k (MetaSel (Just Symbol "uDouble#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UDouble k)))

type Rep (URec k Double p)

type Rep (URec k Double p) = D1 * (MetaData "URec" "GHC.Generics" "base" False) (C1 * (MetaCons "UDouble" PrefixI True) (S1 * (MetaSel (Just Symbol "uDouble#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UDouble *)))

data Char :: *

The character type Char is an enumeration whose values represent Unicode (or equivalently ISO/IEC 10646) characters (see http://www.unicode.org/ for details). This set extends the ISO 8859-1 (Latin-1) character set (the first 256 characters), which is itself an extension of the ASCII character set (the first 128 characters). A character literal in Haskell has type Char.

To convert a Char to or from the corresponding Int value defined by Unicode, use toEnum and fromEnum from the Enum class respectively (or equivalently ord and chr).

Constructors

C# Char#

Instances

Bounded Char

Since: 2.1

Methods

minBound :: Char

maxBound :: Char

Enum Char

Since: 2.1

Methods

succ :: Char -> Char

pred :: Char -> Char

toEnum :: Int -> Char

fromEnum :: Char -> Int

enumFrom :: Char -> [Char]

enumFromThen :: Char -> Char -> [Char]

enumFromTo :: Char -> Char -> [Char]

enumFromThenTo :: Char -> Char -> Char -> [Char]

Eq Char

Methods

(==) :: Char -> Char -> Bool

(/=) :: Char -> Char -> Bool

Data Char

Since: 4.0.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Char -> c Char

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Char

toConstr :: Char -> Constr

dataTypeOf :: Char -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Char)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Char)

gmapT :: (forall b. Data b => b -> b) -> Char -> Char

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Char -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Char -> r

gmapQ :: (forall d. Data d => d -> u) -> Char -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Char -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Char -> m Char

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Char -> m Char

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Char -> m Char

Ord Char

Methods

compare :: Char -> Char -> Ordering

(<) :: Char -> Char -> Bool

(<=) :: Char -> Char -> Bool

(>) :: Char -> Char -> Bool

(>=) :: Char -> Char -> Bool

max :: Char -> Char -> Char

min :: Char -> Char -> Char

Read Char

Since: 2.1

Methods

readsPrec :: Int -> ReadS Char

readList :: ReadS [Char]

readPrec :: ReadPrec Char

readListPrec :: ReadPrec [Char]

Show Char

Since: 2.1

Methods

showsPrec :: Int -> Char -> ShowS

show :: Char -> String

showList :: [Char] -> ShowS

Ix Char

Since: 2.1

Methods

range :: (Char, Char) -> [Char]

index :: (Char, Char) -> Char -> Int

unsafeIndex :: (Char, Char) -> Char -> Int

inRange :: (Char, Char) -> Char -> Bool

rangeSize :: (Char, Char) -> Int

unsafeRangeSize :: (Char, Char) -> Int

Storable Char

Since: 2.1

Methods

sizeOf :: Char -> Int

alignment :: Char -> Int

peekElemOff :: Ptr Char -> Int -> IO Char

pokeElemOff :: Ptr Char -> Int -> Char -> IO ()

peekByteOff :: Ptr b -> Int -> IO Char

pokeByteOff :: Ptr b -> Int -> Char -> IO ()

peek :: Ptr Char -> IO Char

poke :: Ptr Char -> Char -> IO ()

IsChar Char

Since: 2.1

Methods

toChar :: Char -> Char

fromChar :: Char -> Char

PrintfArg Char

Since: 2.1

Methods

formatArg :: Char -> FieldFormatter

parseFormat :: Char -> ModifierParser

Generic1 k (URec k Char)

Associated Types

type Rep1 (URec k Char) (f :: URec k Char -> *) :: k -> *

Methods

from1 :: f a -> Rep1 (URec k Char) f a

to1 :: Rep1 (URec k Char) f a -> f a

Functor (URec * Char)

Methods

fmap :: (a -> b) -> URec * Char a -> URec * Char b

(<$) :: a -> URec * Char b -> URec * Char a

Foldable (URec * Char)

Methods

fold :: Monoid m => URec * Char m -> m

foldMap :: Monoid m => (a -> m) -> URec * Char a -> m

foldr :: (a -> b -> b) -> b -> URec * Char a -> b

foldr' :: (a -> b -> b) -> b -> URec * Char a -> b

foldl :: (b -> a -> b) -> b -> URec * Char a -> b

foldl' :: (b -> a -> b) -> b -> URec * Char a -> b

foldr1 :: (a -> a -> a) -> URec * Char a -> a

foldl1 :: (a -> a -> a) -> URec * Char a -> a

toList :: URec * Char a -> [a]

null :: URec * Char a -> Bool

length :: URec * Char a -> Int

elem :: Eq a => a -> URec * Char a -> Bool

maximum :: Ord a => URec * Char a -> a

minimum :: Ord a => URec * Char a -> a

sum :: Num a => URec * Char a -> a

product :: Num a => URec * Char a -> a

Traversable (URec * Char)

Methods

traverse :: Applicative f => (a -> f b) -> URec * Char a -> f (URec * Char b)

sequenceA :: Applicative f => URec * Char (f a) -> f (URec * Char a)

mapM :: Monad m => (a -> m b) -> URec * Char a -> m (URec * Char b)

sequence :: Monad m => URec * Char (m a) -> m (URec * Char a)

Eq (URec k Char p)

Methods

(==) :: URec k Char p -> URec k Char p -> Bool

(/=) :: URec k Char p -> URec k Char p -> Bool

Ord (URec k Char p)

Methods

compare :: URec k Char p -> URec k Char p -> Ordering

(<) :: URec k Char p -> URec k Char p -> Bool

(<=) :: URec k Char p -> URec k Char p -> Bool

(>) :: URec k Char p -> URec k Char p -> Bool

(>=) :: URec k Char p -> URec k Char p -> Bool

max :: URec k Char p -> URec k Char p -> URec k Char p

min :: URec k Char p -> URec k Char p -> URec k Char p

Show (URec k Char p)

Methods

showsPrec :: Int -> URec k Char p -> ShowS

show :: URec k Char p -> String

showList :: [URec k Char p] -> ShowS

Generic (URec k Char p)

Associated Types

type Rep (URec k Char p) :: * -> *

Methods

from :: URec k Char p -> Rep (URec k Char p) x

to :: Rep (URec k Char p) x -> URec k Char p

data URec k Char

Used for marking occurrences of Char#

Since: 4.9.0.0

data URec k Char = UChar {

• uChar# :: Char#

}

type Rep1 k (URec k Char)

type Rep1 k (URec k Char) = D1 k (MetaData "URec" "GHC.Generics" "base" False) (C1 k (MetaCons "UChar" PrefixI True) (S1 k (MetaSel (Just Symbol "uChar#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UChar k)))

type Rep (URec k Char p)

type Rep (URec k Char p) = D1 * (MetaData "URec" "GHC.Generics" "base" False) (C1 * (MetaCons "UChar" PrefixI True) (S1 * (MetaSel (Just Symbol "uChar#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UChar *)))

data Ptr a

A value of type Ptr a represents a pointer to an object, or an array of objects, which may be marshalled to or from Haskell values of type a.

The type a will often be an instance of class Storable which provides the marshalling operations. However this is not essential, and you can provide your own operations to access the pointer. For example you might write small foreign functions to get or set the fields of a C struct.

Constructors

Ptr Addr#

Instances

Generic1 k (URec k (Ptr ()))

Associated Types

type Rep1 (URec k (Ptr ())) (f :: URec k (Ptr ()) -> *) :: k -> *

Methods

from1 :: f a -> Rep1 (URec k (Ptr ())) f a

to1 :: Rep1 (URec k (Ptr ())) f a -> f a

Eq (Ptr a)

Methods

(==) :: Ptr a -> Ptr a -> Bool

(/=) :: Ptr a -> Ptr a -> Bool

Data a => Data (Ptr a)

Since: 4.8.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ptr a -> c (Ptr a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Ptr a)

toConstr :: Ptr a -> Constr

dataTypeOf :: Ptr a -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Ptr a))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Ptr a))

gmapT :: (forall b. Data b => b -> b) -> Ptr a -> Ptr a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ptr a -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ptr a -> r

gmapQ :: (forall d. Data d => d -> u) -> Ptr a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Ptr a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ptr a -> m (Ptr a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ptr a -> m (Ptr a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ptr a -> m (Ptr a)

Ord (Ptr a)

Methods

compare :: Ptr a -> Ptr a -> Ordering

(<) :: Ptr a -> Ptr a -> Bool

(<=) :: Ptr a -> Ptr a -> Bool

(>) :: Ptr a -> Ptr a -> Bool

(>=) :: Ptr a -> Ptr a -> Bool

max :: Ptr a -> Ptr a -> Ptr a

min :: Ptr a -> Ptr a -> Ptr a

Show (Ptr a)

Since: 2.1

Methods

showsPrec :: Int -> Ptr a -> ShowS

show :: Ptr a -> String

showList :: [Ptr a] -> ShowS

Storable (Ptr a)

Since: 2.1

Methods

sizeOf :: Ptr a -> Int

alignment :: Ptr a -> Int

peekElemOff :: Ptr (Ptr a) -> Int -> IO (Ptr a)

pokeElemOff :: Ptr (Ptr a) -> Int -> Ptr a -> IO ()

peekByteOff :: Ptr b -> Int -> IO (Ptr a)

pokeByteOff :: Ptr b -> Int -> Ptr a -> IO ()

peek :: Ptr (Ptr a) -> IO (Ptr a)

poke :: Ptr (Ptr a) -> Ptr a -> IO ()

Functor (URec * (Ptr ()))

Methods

fmap :: (a -> b) -> URec * (Ptr ()) a -> URec * (Ptr ()) b

(<$) :: a -> URec * (Ptr ()) b -> URec * (Ptr ()) a

Foldable (URec * (Ptr ()))

Methods

fold :: Monoid m => URec * (Ptr ()) m -> m

foldMap :: Monoid m => (a -> m) -> URec * (Ptr ()) a -> m

foldr :: (a -> b -> b) -> b -> URec * (Ptr ()) a -> b

foldr' :: (a -> b -> b) -> b -> URec * (Ptr ()) a -> b

foldl :: (b -> a -> b) -> b -> URec * (Ptr ()) a -> b

foldl' :: (b -> a -> b) -> b -> URec * (Ptr ()) a -> b

foldr1 :: (a -> a -> a) -> URec * (Ptr ()) a -> a

foldl1 :: (a -> a -> a) -> URec * (Ptr ()) a -> a

toList :: URec * (Ptr ()) a -> [a]

null :: URec * (Ptr ()) a -> Bool

length :: URec * (Ptr ()) a -> Int

elem :: Eq a => a -> URec * (Ptr ()) a -> Bool

maximum :: Ord a => URec * (Ptr ()) a -> a

minimum :: Ord a => URec * (Ptr ()) a -> a

sum :: Num a => URec * (Ptr ()) a -> a

product :: Num a => URec * (Ptr ()) a -> a

Traversable (URec * (Ptr ()))

Methods

traverse :: Applicative f => (a -> f b) -> URec * (Ptr ()) a -> f (URec * (Ptr ()) b)

sequenceA :: Applicative f => URec * (Ptr ()) (f a) -> f (URec * (Ptr ()) a)

mapM :: Monad m => (a -> m b) -> URec * (Ptr ()) a -> m (URec * (Ptr ()) b)

sequence :: Monad m => URec * (Ptr ()) (m a) -> m (URec * (Ptr ()) a)

Eq (URec k (Ptr ()) p)

Methods

(==) :: URec k (Ptr ()) p -> URec k (Ptr ()) p -> Bool

(/=) :: URec k (Ptr ()) p -> URec k (Ptr ()) p -> Bool

Ord (URec k (Ptr ()) p)

Methods

compare :: URec k (Ptr ()) p -> URec k (Ptr ()) p -> Ordering

(<) :: URec k (Ptr ()) p -> URec k (Ptr ()) p -> Bool

(<=) :: URec k (Ptr ()) p -> URec k (Ptr ()) p -> Bool

(>) :: URec k (Ptr ()) p -> URec k (Ptr ()) p -> Bool

(>=) :: URec k (Ptr ()) p -> URec k (Ptr ()) p -> Bool

max :: URec k (Ptr ()) p -> URec k (Ptr ()) p -> URec k (Ptr ()) p

min :: URec k (Ptr ()) p -> URec k (Ptr ()) p -> URec k (Ptr ()) p

Generic (URec k (Ptr ()) p)

Associated Types

type Rep (URec k (Ptr ()) p) :: * -> *

Methods

from :: URec k (Ptr ()) p -> Rep (URec k (Ptr ()) p) x

to :: Rep (URec k (Ptr ()) p) x -> URec k (Ptr ()) p

data URec k (Ptr ())

Used for marking occurrences of Addr#

Since: 4.9.0.0

data URec k (Ptr ()) = UAddr {

• uAddr# :: Addr#

}

type Rep1 k (URec k (Ptr ()))

type Rep1 k (URec k (Ptr ())) = D1 k (MetaData "URec" "GHC.Generics" "base" False) (C1 k (MetaCons "UAddr" PrefixI True) (S1 k (MetaSel (Just Symbol "uAddr#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UAddr k)))

type Rep (URec k (Ptr ()) p)

type Rep (URec k (Ptr ()) p) = D1 * (MetaData "URec" "GHC.Generics" "base" False) (C1 * (MetaCons "UAddr" PrefixI True) (S1 * (MetaSel (Just Symbol "uAddr#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UAddr *)))

data FunPtr a

A value of type FunPtr a is a pointer to a function callable from foreign code. The type a will normally be a foreign type, a function type with zero or more arguments where

• the argument types are marshallable foreign types, i.e. Char, Int, Double, Float, Bool, Int8, Int16, Int32, Int64, Word8, Word16, Word32, Word64, Ptr a, FunPtr a, StablePtr a or a renaming of any of these using newtype.
• the return type is either a marshallable foreign type or has the form IO t where t is a marshallable foreign type or ().

A value of type FunPtr a may be a pointer to a foreign function, either returned by another foreign function or imported with a a static address import like

foreign import ccall "stdlib.h &free"
  p_free :: FunPtr (Ptr a -> IO ())

or a pointer to a Haskell function created using a wrapper stub declared to produce a FunPtr of the correct type. For example:

type Compare = Int -> Int -> Bool
foreign import ccall "wrapper"
  mkCompare :: Compare -> IO (FunPtr Compare)

Calls to wrapper stubs like mkCompare allocate storage, which should be released with freeHaskellFunPtr when no longer required.

To convert FunPtr values to corresponding Haskell functions, one can define a dynamic stub for the specific foreign type, e.g.

type IntFunction = CInt -> IO ()
foreign import ccall "dynamic"
  mkFun :: FunPtr IntFunction -> IntFunction

Constructors

FunPtr Addr#

Instances

Eq (FunPtr a)

Methods

(==) :: FunPtr a -> FunPtr a -> Bool

(/=) :: FunPtr a -> FunPtr a -> Bool

Ord (FunPtr a)

Methods

compare :: FunPtr a -> FunPtr a -> Ordering

(<) :: FunPtr a -> FunPtr a -> Bool

(<=) :: FunPtr a -> FunPtr a -> Bool

(>) :: FunPtr a -> FunPtr a -> Bool

(>=) :: FunPtr a -> FunPtr a -> Bool

max :: FunPtr a -> FunPtr a -> FunPtr a

min :: FunPtr a -> FunPtr a -> FunPtr a

Show (FunPtr a)

Since: 2.1

Methods

showsPrec :: Int -> FunPtr a -> ShowS

show :: FunPtr a -> String

showList :: [FunPtr a] -> ShowS

Storable (FunPtr a)

Since: 2.1

Methods

sizeOf :: FunPtr a -> Int

alignment :: FunPtr a -> Int

peekElemOff :: Ptr (FunPtr a) -> Int -> IO (FunPtr a)

pokeElemOff :: Ptr (FunPtr a) -> Int -> FunPtr a -> IO ()

peekByteOff :: Ptr b -> Int -> IO (FunPtr a)

pokeByteOff :: Ptr b -> Int -> FunPtr a -> IO ()

peek :: Ptr (FunPtr a) -> IO (FunPtr a)

poke :: Ptr (FunPtr a) -> FunPtr a -> IO ()

The maximum tuple size

maxTupleSize :: Int

Primitive operations

module GHC.Prim

shiftL# :: Word# -> Int# -> Word#

Shift the argument left by the specified number of bits (which must be non-negative).

shiftRL# :: Word# -> Int# -> Word#

Shift the argument right by the specified number of bits (which must be non-negative). The RL means "right, logical" (as opposed to RA for arithmetic) (although an arithmetic right shift wouldn't make sense for Word#)

iShiftL# :: Int# -> Int# -> Int#

Shift the argument left by the specified number of bits (which must be non-negative).

iShiftRA# :: Int# -> Int# -> Int#

Shift the argument right (signed) by the specified number of bits (which must be non-negative). The RA means "right, arithmetic" (as opposed to RL for logical)

iShiftRL# :: Int# -> Int# -> Int#

Shift the argument right (unsigned) by the specified number of bits (which must be non-negative). The RL means "right, logical" (as opposed to RA for arithmetic)

uncheckedShiftL64# :: Word# -> Int# -> Word#

uncheckedShiftRL64# :: Word# -> Int# -> Word#

uncheckedIShiftL64# :: Int# -> Int# -> Int#

uncheckedIShiftRA64# :: Int# -> Int# -> Int#

isTrue# :: Int# -> Bool

Alias for tagToEnum#. Returns True if its parameter is 1# and False if it is 0#.

Fusion

build :: forall a. (forall b. (a -> b -> b) -> b -> b) -> [a]

A list producer that can be fused with foldr. This function is merely

   build g = g (:) []

but GHC's simplifier will transform an expression of the form foldr k z (build g), which may arise after inlining, to g k z, which avoids producing an intermediate list.

augment :: forall a. (forall b. (a -> b -> b) -> b -> b) -> [a] -> [a]

A list producer that can be fused with foldr. This function is merely

   augment g xs = g (:) xs

but GHC's simplifier will transform an expression of the form foldr k z (augment g xs), which may arise after inlining, to g k (foldr k z xs), which avoids producing an intermediate list.

Overloaded string literals

class IsString a where

Class for string-like datastructures; used by the overloaded string extension (-XOverloadedStrings in GHC).

Minimal complete definition

fromString

Methods

fromString :: String -> a

Instances

(~) * a Char => IsString [a]

(a ~ Char) context was introduced in 4.9.0.0

Since: 2.1

Methods

fromString :: String -> [a]

IsString a => IsString (Identity a)

Methods

fromString :: String -> Identity a

IsString a => IsString (Const * a b)

Since: 4.9.0.0

Methods

fromString :: String -> Const * a b

Debugging

breakpoint :: a -> a

breakpointCond :: Bool -> a -> a

Ids with special behaviour

lazy :: a -> a

The lazy function restrains strictness analysis a little. The call lazy e means the same as e, but lazy has a magical property so far as strictness analysis is concerned: it is lazy in its first argument, even though its semantics is strict. After strictness analysis has run, calls to lazy are inlined to be the identity function.

This behaviour is occasionally useful when controlling evaluation order. Notably, lazy is used in the library definition of par:

par :: a -> b -> b
par x y = case (par# x) of _ -> lazy y

If lazy were not lazy, par would look strict in y which would defeat the whole purpose of par.

Like seq, the argument of lazy can have an unboxed type.

inline :: a -> a

The call inline f arranges that f is inlined, regardless of its size. More precisely, the call inline f rewrites to the right-hand side of f's definition. This allows the programmer to control inlining from a particular call site rather than the definition site of the function (c.f. INLINE pragmas).

This inlining occurs regardless of the argument to the call or the size of f's definition; it is unconditional. The main caveat is that f's definition must be visible to the compiler; it is therefore recommended to mark the function with an INLINABLE pragma at its definition so that GHC guarantees to record its unfolding regardless of size.

If no inlining takes place, the inline function expands to the identity function in Phase zero, so its use imposes no overhead.

oneShot :: (a -> b) -> a -> b

The oneShot function can be used to give a hint to the compiler that its argument will be called at most once, which may (or may not) enable certain optimizations. It can be useful to improve the performance of code in continuation passing style.

If oneShot is used wrongly, then it may be that computations whose result that would otherwise be shared are re-evaluated every time they are used. Otherwise, the use of oneShot is safe.

oneShot is representation polymorphic: the type variables may refer to lifted or unlifted types.

Running RealWorld state transformers

runRW# :: (State# RealWorld -> a) -> a

Apply a function to a 'State# RealWorld' token. When manually applying a function to realWorld#, it is necessary to use NOINLINE to prevent semantically undesirable floating. runRW# is inlined, but only very late in compilation after all floating is complete.

Safe coercions

These are available from the Trustworthy module Data.Coerce as well

Since: 4.7.0.0

coerce :: Coercible * a b => a -> b

The function coerce allows you to safely convert between values of types that have the same representation with no run-time overhead. In the simplest case you can use it instead of a newtype constructor, to go from the newtype's concrete type to the abstract type. But it also works in more complicated settings, e.g. converting a list of newtypes to a list of concrete types.

class (~R#) k0 k0 a b => Coercible k0 (a :: k0) (b :: k0)

Coercible is a two-parameter class that has instances for types a and b if the compiler can infer that they have the same representation. This class does not have regular instances; instead they are created on-the-fly during type-checking. Trying to manually declare an instance of Coercible is an error.

Nevertheless one can pretend that the following three kinds of instances exist. First, as a trivial base-case:

instance Coercible a a

Furthermore, for every type constructor there is an instance that allows to coerce under the type constructor. For example, let D be a prototypical type constructor (data or newtype) with three type arguments, which have roles nominal, representational resp. phantom. Then there is an instance of the form

instance Coercible b b' => Coercible (D a b c) (D a b' c')

Note that the nominal type arguments are equal, the representational type arguments can differ, but need to have a Coercible instance themself, and the phantom type arguments can be changed arbitrarily.

The third kind of instance exists for every newtype NT = MkNT T and comes in two variants, namely

instance Coercible a T => Coercible a NT

instance Coercible T b => Coercible NT b

This instance is only usable if the constructor MkNT is in scope.

If, as a library author of a type constructor like Set a, you want to prevent a user of your module to write coerce :: Set T -> Set NT, you need to set the role of Set's type parameter to nominal, by writing

type role Set nominal

For more details about this feature, please refer to Safe Coercions by Joachim Breitner, Richard A. Eisenberg, Simon Peyton Jones and Stephanie Weirich.

Since: 4.7.0.0

Equality

class (~#) k0 k1 a b => (k0 ~~ k1) (a :: k0) (b :: k1)

Lifted, heterogeneous equality. By lifted, we mean that it can be bogus (deferred type error). By heterogeneous, the two types a and b might have different kinds. Because ~~ can appear unexpectedly in error messages to users who do not care about the difference between heterogeneous equality ~~ and homogeneous equality ~, this is printed as ~ unless -fprint-equality-relations is set.

Representation polymorphism

data TYPE (a :: RuntimeRep) :: RuntimeRep -> *

Instances

Functor f => Generic1 k ((:.:) * k f g)

Associated Types

type Rep1 ((* :.: k) f g) (f :: (* :.: k) f g -> *) :: k -> *

Methods

from1 :: f a -> Rep1 ((* :.: k) f g) f a

to1 :: Rep1 ((* :.: k) f g) f a -> f a

Functor f => Generic1 k (Compose * k f g)

Associated Types

type Rep1 (Compose * k f g) (f :: Compose * k f g -> *) :: k -> *

Methods

from1 :: f a -> Rep1 (Compose * k f g) f a

to1 :: Rep1 (Compose * k f g) f a -> f a

Monad (U1 *)

Since: 4.9.0.0

Methods

(>>=) :: U1 * a -> (a -> U1 * b) -> U1 * b

(>>) :: U1 * a -> U1 * b -> U1 * b

return :: a -> U1 * a

fail :: String -> U1 * a

Monad (Proxy *)

Since: 4.7.0.0

Methods

(>>=) :: Proxy * a -> (a -> Proxy * b) -> Proxy * b

(>>) :: Proxy * a -> Proxy * b -> Proxy * b

return :: a -> Proxy * a

fail :: String -> Proxy * a

Functor (V1 *)

Methods

fmap :: (a -> b) -> V1 * a -> V1 * b

(<$) :: a -> V1 * b -> V1 * a

Functor (U1 *)

Since: 4.9.0.0

Methods

fmap :: (a -> b) -> U1 * a -> U1 * b

(<$) :: a -> U1 * b -> U1 * a

Functor (Proxy *)

Since: 4.7.0.0

Methods

fmap :: (a -> b) -> Proxy * a -> Proxy * b

(<$) :: a -> Proxy * b -> Proxy * a

Applicative (U1 *)

Since: 4.9.0.0

Methods

pure :: a -> U1 * a

(<*>) :: U1 * (a -> b) -> U1 * a -> U1 * b

liftA2 :: (a -> b -> c) -> U1 * a -> U1 * b -> U1 * c

(*>) :: U1 * a -> U1 * b -> U1 * b

(<*) :: U1 * a -> U1 * b -> U1 * a

Applicative (Proxy *)

Since: 4.7.0.0

Methods

pure :: a -> Proxy * a

(<*>) :: Proxy * (a -> b) -> Proxy * a -> Proxy * b

liftA2 :: (a -> b -> c) -> Proxy * a -> Proxy * b -> Proxy * c

(*>) :: Proxy * a -> Proxy * b -> Proxy * b

(<*) :: Proxy * a -> Proxy * b -> Proxy * a

Foldable (V1 *)

Methods

fold :: Monoid m => V1 * m -> m

foldMap :: Monoid m => (a -> m) -> V1 * a -> m

foldr :: (a -> b -> b) -> b -> V1 * a -> b

foldr' :: (a -> b -> b) -> b -> V1 * a -> b

foldl :: (b -> a -> b) -> b -> V1 * a -> b

foldl' :: (b -> a -> b) -> b -> V1 * a -> b

foldr1 :: (a -> a -> a) -> V1 * a -> a

foldl1 :: (a -> a -> a) -> V1 * a -> a

toList :: V1 * a -> [a]

null :: V1 * a -> Bool

length :: V1 * a -> Int

elem :: Eq a => a -> V1 * a -> Bool

maximum :: Ord a => V1 * a -> a

minimum :: Ord a => V1 * a -> a

sum :: Num a => V1 * a -> a

product :: Num a => V1 * a -> a

Foldable (U1 *)

Since: 4.9.0.0

Methods

fold :: Monoid m => U1 * m -> m

foldMap :: Monoid m => (a -> m) -> U1 * a -> m

foldr :: (a -> b -> b) -> b -> U1 * a -> b

foldr' :: (a -> b -> b) -> b -> U1 * a -> b

foldl :: (b -> a -> b) -> b -> U1 * a -> b

foldl' :: (b -> a -> b) -> b -> U1 * a -> b

foldr1 :: (a -> a -> a) -> U1 * a -> a

foldl1 :: (a -> a -> a) -> U1 * a -> a

toList :: U1 * a -> [a]

null :: U1 * a -> Bool

length :: U1 * a -> Int

elem :: Eq a => a -> U1 * a -> Bool

maximum :: Ord a => U1 * a -> a

minimum :: Ord a => U1 * a -> a

sum :: Num a => U1 * a -> a

product :: Num a => U1 * a -> a

Foldable (Proxy *)

Since: 4.7.0.0

Methods

fold :: Monoid m => Proxy * m -> m

foldMap :: Monoid m => (a -> m) -> Proxy * a -> m

foldr :: (a -> b -> b) -> b -> Proxy * a -> b

foldr' :: (a -> b -> b) -> b -> Proxy * a -> b

foldl :: (b -> a -> b) -> b -> Proxy * a -> b

foldl' :: (b -> a -> b) -> b -> Proxy * a -> b

foldr1 :: (a -> a -> a) -> Proxy * a -> a

foldl1 :: (a -> a -> a) -> Proxy * a -> a

toList :: Proxy * a -> [a]

null :: Proxy * a -> Bool

length :: Proxy * a -> Int

elem :: Eq a => a -> Proxy * a -> Bool

maximum :: Ord a => Proxy * a -> a

minimum :: Ord a => Proxy * a -> a

sum :: Num a => Proxy * a -> a

product :: Num a => Proxy * a -> a

Traversable (V1 *)

Methods

traverse :: Applicative f => (a -> f b) -> V1 * a -> f (V1 * b)

sequenceA :: Applicative f => V1 * (f a) -> f (V1 * a)

mapM :: Monad m => (a -> m b) -> V1 * a -> m (V1 * b)

sequence :: Monad m => V1 * (m a) -> m (V1 * a)

Traversable (U1 *)

Since: 4.9.0.0

Methods

traverse :: Applicative f => (a -> f b) -> U1 * a -> f (U1 * b)

sequenceA :: Applicative f => U1 * (f a) -> f (U1 * a)

mapM :: Monad m => (a -> m b) -> U1 * a -> m (U1 * b)

sequence :: Monad m => U1 * (m a) -> m (U1 * a)

Traversable (Proxy *)

Since: 4.7.0.0

Methods

traverse :: Applicative f => (a -> f b) -> Proxy * a -> f (Proxy * b)

sequenceA :: Applicative f => Proxy * (f a) -> f (Proxy * a)

mapM :: Monad m => (a -> m b) -> Proxy * a -> m (Proxy * b)

sequence :: Monad m => Proxy * (m a) -> m (Proxy * a)

MonadPlus (U1 *)

Since: 4.9.0.0

Methods

mzero :: U1 * a

mplus :: U1 * a -> U1 * a -> U1 * a

MonadPlus (Proxy *)

Since: 4.9.0.0

Methods

mzero :: Proxy * a

mplus :: Proxy * a -> Proxy * a -> Proxy * a

Alternative (U1 *)

Since: 4.9.0.0

Methods

empty :: U1 * a

(<|>) :: U1 * a -> U1 * a -> U1 * a

some :: U1 * a -> U1 * [a]

many :: U1 * a -> U1 * [a]

Alternative (Proxy *)

Since: 4.9.0.0

Methods

empty :: Proxy * a

(<|>) :: Proxy * a -> Proxy * a -> Proxy * a

some :: Proxy * a -> Proxy * [a]

many :: Proxy * a -> Proxy * [a]

MonadZip (U1 *)

Since: 4.9.0.0

Methods

mzip :: U1 * a -> U1 * b -> U1 * (a, b)

mzipWith :: (a -> b -> c) -> U1 * a -> U1 * b -> U1 * c

munzip :: U1 * (a, b) -> (U1 * a, U1 * b)

MonadZip (Proxy *)

Since: 4.9.0.0

Methods

mzip :: Proxy * a -> Proxy * b -> Proxy * (a, b)

mzipWith :: (a -> b -> c) -> Proxy * a -> Proxy * b -> Proxy * c

munzip :: Proxy * (a, b) -> (Proxy * a, Proxy * b)

Show2 (Const *)

Since: 4.9.0.0

Methods

liftShowsPrec2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> Int -> Const * a b -> ShowS

liftShowList2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> [Const * a b] -> ShowS

Read2 (Const *)

Since: 4.9.0.0

Methods

liftReadsPrec2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> Int -> ReadS (Const * a b)

liftReadList2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> ReadS [Const * a b]

liftReadPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec (Const * a b)

liftReadListPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec [Const * a b]

Ord2 (Const *)

Since: 4.9.0.0

Methods

liftCompare2 :: (a -> b -> Ordering) -> (c -> d -> Ordering) -> Const * a c -> Const * b d -> Ordering

Eq2 (Const *)

Since: 4.9.0.0

Methods

liftEq2 :: (a -> b -> Bool) -> (c -> d -> Bool) -> Const * a c -> Const * b d -> Bool

Show1 (Proxy *)

Since: 4.9.0.0

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Proxy * a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Proxy * a] -> ShowS

Read1 (Proxy *)

Since: 4.9.0.0

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Proxy * a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Proxy * a]

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Proxy * a)

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Proxy * a]

Ord1 (Proxy *)

Since: 4.9.0.0

Methods

liftCompare :: (a -> b -> Ordering) -> Proxy * a -> Proxy * b -> Ordering

Eq1 (Proxy *)

Since: 4.9.0.0

Methods

liftEq :: (a -> b -> Bool) -> Proxy * a -> Proxy * b -> Bool

Bifunctor (Const *)

Since: 4.8.0.0

Methods

bimap :: (a -> b) -> (c -> d) -> Const * a c -> Const * b d

first :: (a -> b) -> Const * a c -> Const * b c

second :: (b -> c) -> Const * a b -> Const * a c

Bifoldable (Const *)

Since: 4.10.0.0

Methods

bifold :: Monoid m => Const * m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Const * a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Const * a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Const * a b -> c

Bitraversable (Const *)

Since: 4.10.0.0

Methods

bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Const * a b -> f (Const * c d)

Generic1 * []

Associated Types

type Rep1 [] (f :: [] -> *) :: k -> *

Methods

from1 :: f a -> Rep1 [] f a

to1 :: Rep1 [] f a -> f a

Generic1 * Maybe

Associated Types

type Rep1 Maybe (f :: Maybe -> *) :: k -> *

Methods

from1 :: f a -> Rep1 Maybe f a

to1 :: Rep1 Maybe f a -> f a

Generic1 * Par1

Associated Types

type Rep1 Par1 (f :: Par1 -> *) :: k -> *

Methods

from1 :: f a -> Rep1 Par1 f a

to1 :: Rep1 Par1 f a -> f a

Generic1 * Last

Associated Types

type Rep1 Last (f :: Last -> *) :: k -> *

Methods

from1 :: f a -> Rep1 Last f a

to1 :: Rep1 Last f a -> f a

Generic1 * First

Associated Types

type Rep1 First (f :: First -> *) :: k -> *

Methods

from1 :: f a -> Rep1 First f a

to1 :: Rep1 First f a -> f a

Generic1 * Product

Associated Types

type Rep1 Product (f :: Product -> *) :: k -> *

Methods

from1 :: f a -> Rep1 Product f a

to1 :: Rep1 Product f a -> f a

Generic1 * Sum

Associated Types

type Rep1 Sum (f :: Sum -> *) :: k -> *

Methods

from1 :: f a -> Rep1 Sum f a

to1 :: Rep1 Sum f a -> f a

Generic1 * Dual

Associated Types

type Rep1 Dual (f :: Dual -> *) :: k -> *

Methods

from1 :: f a -> Rep1 Dual f a

to1 :: Rep1 Dual f a -> f a

Generic1 * Identity

Associated Types

type Rep1 Identity (f :: Identity -> *) :: k -> *

Methods

from1 :: f a -> Rep1 Identity f a

to1 :: Rep1 Identity f a -> f a

Generic1 * ZipList

Associated Types

type Rep1 ZipList (f :: ZipList -> *) :: k -> *

Methods

from1 :: f a -> Rep1 ZipList f a

to1 :: Rep1 ZipList f a -> f a

Generic1 * NonEmpty

Associated Types

type Rep1 NonEmpty (f :: NonEmpty -> *) :: k -> *

Methods

from1 :: f a -> Rep1 NonEmpty f a

to1 :: Rep1 NonEmpty f a -> f a

Generic1 * Option

Associated Types

type Rep1 Option (f :: Option -> *) :: k -> *

Methods

from1 :: f a -> Rep1 Option f a

to1 :: Rep1 Option f a -> f a

Generic1 * WrappedMonoid

Associated Types

type Rep1 WrappedMonoid (f :: WrappedMonoid -> *) :: k -> *

Methods

from1 :: f a -> Rep1 WrappedMonoid f a

to1 :: Rep1 WrappedMonoid f a -> f a

Generic1 * Last

Associated Types

type Rep1 Last (f :: Last -> *) :: k -> *

Methods

from1 :: f a -> Rep1 Last f a

to1 :: Rep1 Last f a -> f a

Generic1 * First

Associated Types

type Rep1 First (f :: First -> *) :: k -> *

Methods

from1 :: f a -> Rep1 First f a

to1 :: Rep1 First f a -> f a

Generic1 * Max

Associated Types

type Rep1 Max (f :: Max -> *) :: k -> *

Methods

from1 :: f a -> Rep1 Max f a

to1 :: Rep1 Max f a -> f a

Generic1 * Min

Associated Types

type Rep1 Min (f :: Min -> *) :: k -> *

Methods

from1 :: f a -> Rep1 Min f a

to1 :: Rep1 Min f a -> f a

Generic1 * Complex

Associated Types

type Rep1 Complex (f :: Complex -> *) :: k -> *

Methods

from1 :: f a -> Rep1 Complex f a

to1 :: Rep1 Complex f a -> f a

Generic1 * (Either a)

Associated Types

type Rep1 (Either a) (f :: Either a -> *) :: k -> *

Methods

from1 :: f a -> Rep1 (Either a) f a

to1 :: Rep1 (Either a) f a -> f a

Generic1 * ((,) a)

Associated Types

type Rep1 ((,) a) (f :: (,) a -> *) :: k -> *

Methods

from1 :: f a -> Rep1 ((,) a) f a

to1 :: Rep1 ((,) a) f a -> f a

Generic1 * (WrappedMonad m)

Associated Types

type Rep1 (WrappedMonad m) (f :: WrappedMonad m -> *) :: k -> *

Methods

from1 :: f a -> Rep1 (WrappedMonad m) f a

to1 :: Rep1 (WrappedMonad m) f a -> f a

Generic1 * (Arg a)

Associated Types

type Rep1 (Arg a) (f :: Arg a -> *) :: k -> *

Methods

from1 :: f a -> Rep1 (Arg a) f a

to1 :: Rep1 (Arg a) f a -> f a

Monad m => Category * (Kleisli m)

Since: 3.0

Methods

id :: cat a a

(.) :: cat b c -> cat a b -> cat a c

Generic1 * ((,,) a b)

Associated Types

type Rep1 ((,,) a b) (f :: (,,) a b -> *) :: k -> *

Methods

from1 :: f a -> Rep1 ((,,) a b) f a

to1 :: Rep1 ((,,) a b) f a -> f a

Generic1 * (WrappedArrow a b)

Associated Types

type Rep1 (WrappedArrow a b) (f :: WrappedArrow a b -> *) :: k -> *

Methods

from1 :: f a -> Rep1 (WrappedArrow a b) f a

to1 :: Rep1 (WrappedArrow a b) f a -> f a

Category * ((->) LiftedRep LiftedRep)

Since: 3.0

Methods

id :: cat a a

(.) :: cat b c -> cat a b -> cat a c

Generic1 * ((,,,) a b c)

Associated Types

type Rep1 ((,,,) a b c) (f :: (,,,) a b c -> *) :: k -> *

Methods

from1 :: f a -> Rep1 ((,,,) a b c) f a

to1 :: Rep1 ((,,,) a b c) f a -> f a

Generic1 * ((,,,,) a b c d)

Associated Types

type Rep1 ((,,,,) a b c d) (f :: (,,,,) a b c d -> *) :: k -> *

Methods

from1 :: f a -> Rep1 ((,,,,) a b c d) f a

to1 :: Rep1 ((,,,,) a b c d) f a -> f a

Generic1 * ((,,,,,) a b c d e)

Associated Types

type Rep1 ((,,,,,) a b c d e) (f :: (,,,,,) a b c d e -> *) :: k -> *

Methods

from1 :: f a -> Rep1 ((,,,,,) a b c d e) f a

to1 :: Rep1 ((,,,,,) a b c d e) f a -> f a

Generic1 * ((,,,,,,) a b c d e f)

Associated Types

type Rep1 ((,,,,,,) a b c d e f) (f :: (,,,,,,) a b c d e f -> *) :: k -> *

Methods

from1 :: f a -> Rep1 ((,,,,,,) a b c d e f) f a

to1 :: Rep1 ((,,,,,,) a b c d e f) f a -> f a

Monad f => Monad (Rec1 * f)

Since: 4.9.0.0

Methods

(>>=) :: Rec1 * f a -> (a -> Rec1 * f b) -> Rec1 * f b

(>>) :: Rec1 * f a -> Rec1 * f b -> Rec1 * f b

return :: a -> Rec1 * f a

fail :: String -> Rec1 * f a

Monad f => Monad (Alt * f)

Methods

(>>=) :: Alt * f a -> (a -> Alt * f b) -> Alt * f b

(>>) :: Alt * f a -> Alt * f b -> Alt * f b

return :: a -> Alt * f a

fail :: String -> Alt * f a

Data p => Data (V1 * p)

Since: 4.9.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> V1 * p -> c (V1 * p)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (V1 * p)

toConstr :: V1 * p -> Constr

dataTypeOf :: V1 * p -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (V1 * p))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (V1 * p))

gmapT :: (forall b. Data b => b -> b) -> V1 * p -> V1 * p

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> V1 * p -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> V1 * p -> r

gmapQ :: (forall d. Data d => d -> u) -> V1 * p -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> V1 * p -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> V1 * p -> m (V1 * p)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> V1 * p -> m (V1 * p)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> V1 * p -> m (V1 * p)

Data p => Data (U1 * p)

Since: 4.9.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> U1 * p -> c (U1 * p)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (U1 * p)

toConstr :: U1 * p -> Constr

dataTypeOf :: U1 * p -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (U1 * p))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (U1 * p))

gmapT :: (forall b. Data b => b -> b) -> U1 * p -> U1 * p

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> U1 * p -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> U1 * p -> r

gmapQ :: (forall d. Data d => d -> u) -> U1 * p -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> U1 * p -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> U1 * p -> m (U1 * p)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> U1 * p -> m (U1 * p)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> U1 * p -> m (U1 * p)

Data t => Data (Proxy * t)

Since: 4.7.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Proxy * t -> c (Proxy * t)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Proxy * t)

toConstr :: Proxy * t -> Constr

dataTypeOf :: Proxy * t -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Proxy * t))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Proxy * t))

gmapT :: (forall b. Data b => b -> b) -> Proxy * t -> Proxy * t

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Proxy * t -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Proxy * t -> r

gmapQ :: (forall d. Data d => d -> u) -> Proxy * t -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Proxy * t -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Proxy * t -> m (Proxy * t)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Proxy * t -> m (Proxy * t)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Proxy * t -> m (Proxy * t)

Functor f => Functor (Rec1 * f)

Methods

fmap :: (a -> b) -> Rec1 * f a -> Rec1 * f b

(<$) :: a -> Rec1 * f b -> Rec1 * f a

Functor (URec * Char)

Methods

fmap :: (a -> b) -> URec * Char a -> URec * Char b

(<$) :: a -> URec * Char b -> URec * Char a

Functor (URec * Double)

Methods

fmap :: (a -> b) -> URec * Double a -> URec * Double b

(<$) :: a -> URec * Double b -> URec * Double a

Functor (URec * Float)

Methods

fmap :: (a -> b) -> URec * Float a -> URec * Float b

(<$) :: a -> URec * Float b -> URec * Float a

Functor (URec * Int)

Methods

fmap :: (a -> b) -> URec * Int a -> URec * Int b

(<$) :: a -> URec * Int b -> URec * Int a

Functor (URec * Word)

Methods

fmap :: (a -> b) -> URec * Word a -> URec * Word b

(<$) :: a -> URec * Word b -> URec * Word a

Functor (URec * (Ptr ()))

Methods

fmap :: (a -> b) -> URec * (Ptr ()) a -> URec * (Ptr ()) b

(<$) :: a -> URec * (Ptr ()) b -> URec * (Ptr ()) a

Functor f => Functor (Alt * f)

Methods

fmap :: (a -> b) -> Alt * f a -> Alt * f b

(<$) :: a -> Alt * f b -> Alt * f a

Functor (Const * m)

Since: 2.1

Methods

fmap :: (a -> b) -> Const * m a -> Const * m b

(<$) :: a -> Const * m b -> Const * m a

MonadFix f => MonadFix (Rec1 * f)

Since: 4.9.0.0

Methods

mfix :: (a -> Rec1 * f a) -> Rec1 * f a

MonadFix f => MonadFix (Alt * f)

Since: 4.8.0.0

Methods

mfix :: (a -> Alt * f a) -> Alt * f a

Applicative f => Applicative (Rec1 * f)

Since: 4.9.0.0

Methods

pure :: a -> Rec1 * f a

(<*>) :: Rec1 * f (a -> b) -> Rec1 * f a -> Rec1 * f b

liftA2 :: (a -> b -> c) -> Rec1 * f a -> Rec1 * f b -> Rec1 * f c

(*>) :: Rec1 * f a -> Rec1 * f b -> Rec1 * f b

(<*) :: Rec1 * f a -> Rec1 * f b -> Rec1 * f a

Applicative f => Applicative (Alt * f)

Methods

pure :: a -> Alt * f a

(<*>) :: Alt * f (a -> b) -> Alt * f a -> Alt * f b

liftA2 :: (a -> b -> c) -> Alt * f a -> Alt * f b -> Alt * f c

(*>) :: Alt * f a -> Alt * f b -> Alt * f b

(<*) :: Alt * f a -> Alt * f b -> Alt * f a

Monoid m => Applicative (Const * m)

Since: 2.0.1

Methods

pure :: a -> Const * m a

(<*>) :: Const * m (a -> b) -> Const * m a -> Const * m b

liftA2 :: (a -> b -> c) -> Const * m a -> Const * m b -> Const * m c

(*>) :: Const * m a -> Const * m b -> Const * m b

(<*) :: Const * m a -> Const * m b -> Const * m a

Foldable f => Foldable (Rec1 * f)

Methods

fold :: Monoid m => Rec1 * f m -> m

foldMap :: Monoid m => (a -> m) -> Rec1 * f a -> m

foldr :: (a -> b -> b) -> b -> Rec1 * f a -> b

foldr' :: (a -> b -> b) -> b -> Rec1 * f a -> b

foldl :: (b -> a -> b) -> b -> Rec1 * f a -> b

foldl' :: (b -> a -> b) -> b -> Rec1 * f a -> b

foldr1 :: (a -> a -> a) -> Rec1 * f a -> a

foldl1 :: (a -> a -> a) -> Rec1 * f a -> a

toList :: Rec1 * f a -> [a]

null :: Rec1 * f a -> Bool

length :: Rec1 * f a -> Int

elem :: Eq a => a -> Rec1 * f a -> Bool

maximum :: Ord a => Rec1 * f a -> a

minimum :: Ord a => Rec1 * f a -> a

sum :: Num a => Rec1 * f a -> a

product :: Num a => Rec1 * f a -> a

Foldable (URec * Char)

Methods

fold :: Monoid m => URec * Char m -> m

foldMap :: Monoid m => (a -> m) -> URec * Char a -> m

foldr :: (a -> b -> b) -> b -> URec * Char a -> b

foldr' :: (a -> b -> b) -> b -> URec * Char a -> b

foldl :: (b -> a -> b) -> b -> URec * Char a -> b

foldl' :: (b -> a -> b) -> b -> URec * Char a -> b

foldr1 :: (a -> a -> a) -> URec * Char a -> a

foldl1 :: (a -> a -> a) -> URec * Char a -> a

toList :: URec * Char a -> [a]

null :: URec * Char a -> Bool

length :: URec * Char a -> Int

elem :: Eq a => a -> URec * Char a -> Bool

maximum :: Ord a => URec * Char a -> a

minimum :: Ord a => URec * Char a -> a

sum :: Num a => URec * Char a -> a

product :: Num a => URec * Char a -> a

Foldable (URec * Double)

Methods

fold :: Monoid m => URec * Double m -> m

foldMap :: Monoid m => (a -> m) -> URec * Double a -> m

foldr :: (a -> b -> b) -> b -> URec * Double a -> b

foldr' :: (a -> b -> b) -> b -> URec * Double a -> b

foldl :: (b -> a -> b) -> b -> URec * Double a -> b

foldl' :: (b -> a -> b) -> b -> URec * Double a -> b

foldr1 :: (a -> a -> a) -> URec * Double a -> a

foldl1 :: (a -> a -> a) -> URec * Double a -> a

toList :: URec * Double a -> [a]

null :: URec * Double a -> Bool

length :: URec * Double a -> Int

elem :: Eq a => a -> URec * Double a -> Bool

maximum :: Ord a => URec * Double a -> a

minimum :: Ord a => URec * Double a -> a

sum :: Num a => URec * Double a -> a

product :: Num a => URec * Double a -> a

Foldable (URec * Float)

Methods

fold :: Monoid m => URec * Float m -> m

foldMap :: Monoid m => (a -> m) -> URec * Float a -> m

foldr :: (a -> b -> b) -> b -> URec * Float a -> b

foldr' :: (a -> b -> b) -> b -> URec * Float a -> b

foldl :: (b -> a -> b) -> b -> URec * Float a -> b

foldl' :: (b -> a -> b) -> b -> URec * Float a -> b

foldr1 :: (a -> a -> a) -> URec * Float a -> a

foldl1 :: (a -> a -> a) -> URec * Float a -> a

toList :: URec * Float a -> [a]

null :: URec * Float a -> Bool

length :: URec * Float a -> Int

elem :: Eq a => a -> URec * Float a -> Bool

maximum :: Ord a => URec * Float a -> a

minimum :: Ord a => URec * Float a -> a

sum :: Num a => URec * Float a -> a

product :: Num a => URec * Float a -> a

Foldable (URec * Int)

Methods

fold :: Monoid m => URec * Int m -> m

foldMap :: Monoid m => (a -> m) -> URec * Int a -> m

foldr :: (a -> b -> b) -> b -> URec * Int a -> b

foldr' :: (a -> b -> b) -> b -> URec * Int a -> b

foldl :: (b -> a -> b) -> b -> URec * Int a -> b

foldl' :: (b -> a -> b) -> b -> URec * Int a -> b

foldr1 :: (a -> a -> a) -> URec * Int a -> a

foldl1 :: (a -> a -> a) -> URec * Int a -> a

toList :: URec * Int a -> [a]

null :: URec * Int a -> Bool

length :: URec * Int a -> Int

elem :: Eq a => a -> URec * Int a -> Bool

maximum :: Ord a => URec * Int a -> a

minimum :: Ord a => URec * Int a -> a

sum :: Num a => URec * Int a -> a

product :: Num a => URec * Int a -> a

Foldable (URec * Word)

Methods

fold :: Monoid m => URec * Word m -> m

foldMap :: Monoid m => (a -> m) -> URec * Word a -> m

foldr :: (a -> b -> b) -> b -> URec * Word a -> b

foldr' :: (a -> b -> b) -> b -> URec * Word a -> b

foldl :: (b -> a -> b) -> b -> URec * Word a -> b

foldl' :: (b -> a -> b) -> b -> URec * Word a -> b

foldr1 :: (a -> a -> a) -> URec * Word a -> a

foldl1 :: (a -> a -> a) -> URec * Word a -> a

toList :: URec * Word a -> [a]

null :: URec * Word a -> Bool

length :: URec * Word a -> Int

elem :: Eq a => a -> URec * Word a -> Bool

maximum :: Ord a => URec * Word a -> a

minimum :: Ord a => URec * Word a -> a

sum :: Num a => URec * Word a -> a

product :: Num a => URec * Word a -> a

Foldable (URec * (Ptr ()))

Methods

fold :: Monoid m => URec * (Ptr ()) m -> m

foldMap :: Monoid m => (a -> m) -> URec * (Ptr ()) a -> m

foldr :: (a -> b -> b) -> b -> URec * (Ptr ()) a -> b

foldr' :: (a -> b -> b) -> b -> URec * (Ptr ()) a -> b

foldl :: (b -> a -> b) -> b -> URec * (Ptr ()) a -> b

foldl' :: (b -> a -> b) -> b -> URec * (Ptr ()) a -> b

foldr1 :: (a -> a -> a) -> URec * (Ptr ()) a -> a

foldl1 :: (a -> a -> a) -> URec * (Ptr ()) a -> a

toList :: URec * (Ptr ()) a -> [a]

null :: URec * (Ptr ()) a -> Bool

length :: URec * (Ptr ()) a -> Int

elem :: Eq a => a -> URec * (Ptr ()) a -> Bool

maximum :: Ord a => URec * (Ptr ()) a -> a

minimum :: Ord a => URec * (Ptr ()) a -> a

sum :: Num a => URec * (Ptr ()) a -> a

product :: Num a => URec * (Ptr ()) a -> a

Foldable (Const * m)

Since: 4.7.0.0

Methods

fold :: Monoid m => Const * m m -> m

foldMap :: Monoid m => (a -> m) -> Const * m a -> m

foldr :: (a -> b -> b) -> b -> Const * m a -> b

foldr' :: (a -> b -> b) -> b -> Const * m a -> b

foldl :: (b -> a -> b) -> b -> Const * m a -> b

foldl' :: (b -> a -> b) -> b -> Const * m a -> b

foldr1 :: (a -> a -> a) -> Const * m a -> a

foldl1 :: (a -> a -> a) -> Const * m a -> a

toList :: Const * m a -> [a]

null :: Const * m a -> Bool

length :: Const * m a -> Int

elem :: Eq a => a -> Const * m a -> Bool

maximum :: Ord a => Const * m a -> a

minimum :: Ord a => Const * m a -> a

sum :: Num a => Const * m a -> a

product :: Num a => Const * m a -> a

Traversable f => Traversable (Rec1 * f)

Methods

traverse :: Applicative f => (a -> f b) -> Rec1 * f a -> f (Rec1 * f b)

sequenceA :: Applicative f => Rec1 * f (f a) -> f (Rec1 * f a)

mapM :: Monad m => (a -> m b) -> Rec1 * f a -> m (Rec1 * f b)

sequence :: Monad m => Rec1 * f (m a) -> m (Rec1 * f a)

Traversable (URec * Char)

Methods

traverse :: Applicative f => (a -> f b) -> URec * Char a -> f (URec * Char b)

sequenceA :: Applicative f => URec * Char (f a) -> f (URec * Char a)

mapM :: Monad m => (a -> m b) -> URec * Char a -> m (URec * Char b)

sequence :: Monad m => URec * Char (m a) -> m (URec * Char a)

Traversable (URec * Double)

Methods

traverse :: Applicative f => (a -> f b) -> URec * Double a -> f (URec * Double b)

sequenceA :: Applicative f => URec * Double (f a) -> f (URec * Double a)

mapM :: Monad m => (a -> m b) -> URec * Double a -> m (URec * Double b)

sequence :: Monad m => URec * Double (m a) -> m (URec * Double a)

Traversable (URec * Float)

Methods

traverse :: Applicative f => (a -> f b) -> URec * Float a -> f (URec * Float b)

sequenceA :: Applicative f => URec * Float (f a) -> f (URec * Float a)

mapM :: Monad m => (a -> m b) -> URec * Float a -> m (URec * Float b)

sequence :: Monad m => URec * Float (m a) -> m (URec * Float a)

Traversable (URec * Int)

Methods

traverse :: Applicative f => (a -> f b) -> URec * Int a -> f (URec * Int b)

sequenceA :: Applicative f => URec * Int (f a) -> f (URec * Int a)

mapM :: Monad m => (a -> m b) -> URec * Int a -> m (URec * Int b)

sequence :: Monad m => URec * Int (m a) -> m (URec * Int a)

Traversable (URec * Word)

Methods

traverse :: Applicative f => (a -> f b) -> URec * Word a -> f (URec * Word b)

sequenceA :: Applicative f => URec * Word (f a) -> f (URec * Word a)

mapM :: Monad m => (a -> m b) -> URec * Word a -> m (URec * Word b)

sequence :: Monad m => URec * Word (m a) -> m (URec * Word a)

Traversable (URec * (Ptr ()))

Methods

traverse :: Applicative f => (a -> f b) -> URec * (Ptr ()) a -> f (URec * (Ptr ()) b)

sequenceA :: Applicative f => URec * (Ptr ()) (f a) -> f (URec * (Ptr ()) a)

mapM :: Monad m => (a -> m b) -> URec * (Ptr ()) a -> m (URec * (Ptr ()) b)

sequence :: Monad m => URec * (Ptr ()) (m a) -> m (URec * (Ptr ()) a)

Traversable (Const * m)

Since: 4.7.0.0

Methods

traverse :: Applicative f => (a -> f b) -> Const * m a -> f (Const * m b)

sequenceA :: Applicative f => Const * m (f a) -> f (Const * m a)

mapM :: Monad m => (a -> m b) -> Const * m a -> m (Const * m b)

sequence :: Monad m => Const * m (m a) -> m (Const * m a)

MonadPlus f => MonadPlus (Rec1 * f)

Since: 4.9.0.0

Methods

mzero :: Rec1 * f a

mplus :: Rec1 * f a -> Rec1 * f a -> Rec1 * f a

MonadPlus f => MonadPlus (Alt * f)

Methods

mzero :: Alt * f a

mplus :: Alt * f a -> Alt * f a -> Alt * f a

Alternative f => Alternative (Rec1 * f)

Since: 4.9.0.0

Methods

empty :: Rec1 * f a

(<|>) :: Rec1 * f a -> Rec1 * f a -> Rec1 * f a

some :: Rec1 * f a -> Rec1 * f [a]

many :: Rec1 * f a -> Rec1 * f [a]

Alternative f => Alternative (Alt * f)

Methods

empty :: Alt * f a

(<|>) :: Alt * f a -> Alt * f a -> Alt * f a

some :: Alt * f a -> Alt * f [a]

many :: Alt * f a -> Alt * f [a]

MonadZip f => MonadZip (Rec1 * f)

Since: 4.9.0.0

Methods

mzip :: Rec1 * f a -> Rec1 * f b -> Rec1 * f (a, b)

mzipWith :: (a -> b -> c) -> Rec1 * f a -> Rec1 * f b -> Rec1 * f c

munzip :: Rec1 * f (a, b) -> (Rec1 * f a, Rec1 * f b)

MonadZip f => MonadZip (Alt * f)

Since: 4.8.0.0

Methods

mzip :: Alt * f a -> Alt * f b -> Alt * f (a, b)

mzipWith :: (a -> b -> c) -> Alt * f a -> Alt * f b -> Alt * f c

munzip :: Alt * f (a, b) -> (Alt * f a, Alt * f b)

Show a => Show1 (Const * a)

Since: 4.9.0.0

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Const * a a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Const * a a] -> ShowS

Read a => Read1 (Const * a)

Since: 4.9.0.0

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Const * a a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Const * a a]

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Const * a a)

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Const * a a]

Ord a => Ord1 (Const * a)

Since: 4.9.0.0

Methods

liftCompare :: (a -> b -> Ordering) -> Const * a a -> Const * a b -> Ordering

Eq a => Eq1 (Const * a)

Since: 4.9.0.0

Methods

liftEq :: (a -> b -> Bool) -> Const * a a -> Const * a b -> Bool

Bifunctor (K1 * i)

Since: 4.9.0.0

Methods

bimap :: (a -> b) -> (c -> d) -> K1 * i a c -> K1 * i b d

first :: (a -> b) -> K1 * i a c -> K1 * i b c

second :: (b -> c) -> K1 * i a b -> K1 * i a c

Bifoldable (K1 * i)

Since: 4.10.0.0

Methods

bifold :: Monoid m => K1 * i m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> K1 * i a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> K1 * i a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> K1 * i a b -> c

Bitraversable (K1 * i)

Since: 4.10.0.0

Methods

bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> K1 * i a b -> f (K1 * i c d)

(Monad f, Monad g) => Monad ((:*:) * f g)

Since: 4.9.0.0

Methods

(>>=) :: (* :*: f) g a -> (a -> (* :*: f) g b) -> (* :*: f) g b

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

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

fail :: String -> (* :*: f) g a

(Monad f, Monad g) => Monad (Product * f g)

Since: 4.9.0.0

Methods

(>>=) :: Product * f g a -> (a -> Product * f g b) -> Product * f g b

(>>) :: Product * f g a -> Product * f g b -> Product * f g b

return :: a -> Product * f g a

fail :: String -> Product * f g a

(Data (f p), Typeable (* -> *) f, Data p) => Data (Rec1 * f p)

Since: 4.9.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Rec1 * f p -> c (Rec1 * f p)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Rec1 * f p)

toConstr :: Rec1 * f p -> Constr

dataTypeOf :: Rec1 * f p -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Rec1 * f p))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Rec1 * f p))

gmapT :: (forall b. Data b => b -> b) -> Rec1 * f p -> Rec1 * f p

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Rec1 * f p -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Rec1 * f p -> r

gmapQ :: (forall d. Data d => d -> u) -> Rec1 * f p -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Rec1 * f p -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Rec1 * f p -> m (Rec1 * f p)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Rec1 * f p -> m (Rec1 * f p)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Rec1 * f p -> m (Rec1 * f p)

((~) * a b, Data a) => Data ((:~:) * a b)

Since: 4.7.0.0

Methods

gfoldl :: (forall d c. Data d => c (d -> c) -> d -> c c) -> (forall g. g -> c g) -> (* :~: a) b -> c ((* :~: a) b)

gunfold :: (forall c r. Data c => c (c -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ((* :~: a) b)

toConstr :: (* :~: a) b -> Constr

dataTypeOf :: (* :~: a) b -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ((* :~: a) b))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ((* :~: a) b))

gmapT :: (forall c. Data c => c -> c) -> (* :~: a) b -> (* :~: a) b

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (* :~: a) b -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (* :~: a) b -> r

gmapQ :: (forall d. Data d => d -> u) -> (* :~: a) b -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> (* :~: a) b -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> (* :~: a) b -> m ((* :~: a) b)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (* :~: a) b -> m ((* :~: a) b)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (* :~: a) b -> m ((* :~: a) b)

(Coercible * a b, Data a, Data b) => Data (Coercion * a b)

Since: 4.7.0.0

Methods

gfoldl :: (forall d c. Data d => c (d -> c) -> d -> c c) -> (forall g. g -> c g) -> Coercion * a b -> c (Coercion * a b)

gunfold :: (forall c r. Data c => c (c -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Coercion * a b)

toConstr :: Coercion * a b -> Constr

dataTypeOf :: Coercion * a b -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Coercion * a b))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Coercion * a b))

gmapT :: (forall c. Data c => c -> c) -> Coercion * a b -> Coercion * a b

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Coercion * a b -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Coercion * a b -> r

gmapQ :: (forall d. Data d => d -> u) -> Coercion * a b -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Coercion * a b -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Coercion * a b -> m (Coercion * a b)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Coercion * a b -> m (Coercion * a b)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Coercion * a b -> m (Coercion * a b)

(Data (f a), Data a, Typeable (* -> *) f) => Data (Alt * f a)

Since: 4.8.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Alt * f a -> c (Alt * f a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Alt * f a)

toConstr :: Alt * f a -> Constr

dataTypeOf :: Alt * f a -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Alt * f a))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Alt * f a))

gmapT :: (forall b. Data b => b -> b) -> Alt * f a -> Alt * f a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Alt * f a -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Alt * f a -> r

gmapQ :: (forall d. Data d => d -> u) -> Alt * f a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Alt * f a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Alt * f a -> m (Alt * f a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Alt * f a -> m (Alt * f a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Alt * f a -> m (Alt * f a)

Functor (K1 * i c)

Methods

fmap :: (a -> b) -> K1 * i c a -> K1 * i c b

(<$) :: a -> K1 * i c b -> K1 * i c a

(Functor g, Functor f) => Functor ((:+:) * f g)

Methods

fmap :: (a -> b) -> (* :+: f) g a -> (* :+: f) g b

(<$) :: a -> (* :+: f) g b -> (* :+: f) g a

(Functor g, Functor f) => Functor ((:*:) * f g)

Methods

fmap :: (a -> b) -> (* :*: f) g a -> (* :*: f) g b

(<$) :: a -> (* :*: f) g b -> (* :*: f) g a

(Functor f, Functor g) => Functor (Sum * f g)

Since: 4.9.0.0

Methods

fmap :: (a -> b) -> Sum * f g a -> Sum * f g b

(<$) :: a -> Sum * f g b -> Sum * f g a

(Functor f, Functor g) => Functor (Product * f g)

Since: 4.9.0.0

Methods

fmap :: (a -> b) -> Product * f g a -> Product * f g b

(<$) :: a -> Product * f g b -> Product * f g a

(MonadFix f, MonadFix g) => MonadFix ((:*:) * f g)

Since: 4.9.0.0

Methods

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

(MonadFix f, MonadFix g) => MonadFix (Product * f g)

Since: 4.9.0.0

Methods

mfix :: (a -> Product * f g a) -> Product * f g a

IsString a => IsString (Const * a b)

Since: 4.9.0.0

Methods

fromString :: String -> Const * a b

(Applicative f, Applicative g) => Applicative ((:*:) * f g)

Since: 4.9.0.0

Methods

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

(<*>) :: (* :*: f) g (a -> b) -> (* :*: f) g a -> (* :*: f) g b

liftA2 :: (a -> b -> c) -> (* :*: f) g a -> (* :*: f) g b -> (* :*: f) g c

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

(<*) :: (* :*: f) g a -> (* :*: f) g b -> (* :*: f) g a

(Applicative f, Applicative g) => Applicative (Product * f g)

Since: 4.9.0.0

Methods

pure :: a -> Product * f g a

(<*>) :: Product * f g (a -> b) -> Product * f g a -> Product * f g b

liftA2 :: (a -> b -> c) -> Product * f g a -> Product * f g b -> Product * f g c

(*>) :: Product * f g a -> Product * f g b -> Product * f g b

(<*) :: Product * f g a -> Product * f g b -> Product * f g a

Foldable (K1 * i c)

Methods

fold :: Monoid m => K1 * i c m -> m

foldMap :: Monoid m => (a -> m) -> K1 * i c a -> m

foldr :: (a -> b -> b) -> b -> K1 * i c a -> b

foldr' :: (a -> b -> b) -> b -> K1 * i c a -> b

foldl :: (b -> a -> b) -> b -> K1 * i c a -> b

foldl' :: (b -> a -> b) -> b -> K1 * i c a -> b

foldr1 :: (a -> a -> a) -> K1 * i c a -> a

foldl1 :: (a -> a -> a) -> K1 * i c a -> a

toList :: K1 * i c a -> [a]

null :: K1 * i c a -> Bool

length :: K1 * i c a -> Int

elem :: Eq a => a -> K1 * i c a -> Bool

maximum :: Ord a => K1 * i c a -> a

minimum :: Ord a => K1 * i c a -> a

sum :: Num a => K1 * i c a -> a

product :: Num a => K1 * i c a -> a

(Foldable f, Foldable g) => Foldable ((:+:) * f g)

Methods

fold :: Monoid m => (* :+: f) g m -> m

foldMap :: Monoid m => (a -> m) -> (* :+: f) g a -> m

foldr :: (a -> b -> b) -> b -> (* :+: f) g a -> b

foldr' :: (a -> b -> b) -> b -> (* :+: f) g a -> b

foldl :: (b -> a -> b) -> b -> (* :+: f) g a -> b

foldl' :: (b -> a -> b) -> b -> (* :+: f) g a -> b

foldr1 :: (a -> a -> a) -> (* :+: f) g a -> a

foldl1 :: (a -> a -> a) -> (* :+: f) g a -> a

toList :: (* :+: f) g a -> [a]

null :: (* :+: f) g a -> Bool

length :: (* :+: f) g a -> Int

elem :: Eq a => a -> (* :+: f) g a -> Bool

maximum :: Ord a => (* :+: f) g a -> a

minimum :: Ord a => (* :+: f) g a -> a

sum :: Num a => (* :+: f) g a -> a

product :: Num a => (* :+: f) g a -> a

(Foldable f, Foldable g) => Foldable ((:*:) * f g)

Methods

fold :: Monoid m => (* :*: f) g m -> m

foldMap :: Monoid m => (a -> m) -> (* :*: f) g a -> m

foldr :: (a -> b -> b) -> b -> (* :*: f) g a -> b

foldr' :: (a -> b -> b) -> b -> (* :*: f) g a -> b

foldl :: (b -> a -> b) -> b -> (* :*: f) g a -> b

foldl' :: (b -> a -> b) -> b -> (* :*: f) g a -> b

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

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

toList :: (* :*: f) g a -> [a]

null :: (* :*: f) g a -> Bool

length :: (* :*: f) g a -> Int

elem :: Eq a => a -> (* :*: f) g a -> Bool

maximum :: Ord a => (* :*: f) g a -> a

minimum :: Ord a => (* :*: f) g a -> a

sum :: Num a => (* :*: f) g a -> a

product :: Num a => (* :*: f) g a -> a

(Foldable f, Foldable g) => Foldable (Sum * f g)

Since: 4.9.0.0

Methods

fold :: Monoid m => Sum * f g m -> m

foldMap :: Monoid m => (a -> m) -> Sum * f g a -> m

foldr :: (a -> b -> b) -> b -> Sum * f g a -> b

foldr' :: (a -> b -> b) -> b -> Sum * f g a -> b

foldl :: (b -> a -> b) -> b -> Sum * f g a -> b

foldl' :: (b -> a -> b) -> b -> Sum * f g a -> b

foldr1 :: (a -> a -> a) -> Sum * f g a -> a

foldl1 :: (a -> a -> a) -> Sum * f g a -> a

toList :: Sum * f g a -> [a]

null :: Sum * f g a -> Bool

length :: Sum * f g a -> Int

elem :: Eq a => a -> Sum * f g a -> Bool

maximum :: Ord a => Sum * f g a -> a

minimum :: Ord a => Sum * f g a -> a

sum :: Num a => Sum * f g a -> a

product :: Num a => Sum * f g a -> a

(Foldable f, Foldable g) => Foldable (Product * f g)

Since: 4.9.0.0

Methods

fold :: Monoid m => Product * f g m -> m

foldMap :: Monoid m => (a -> m) -> Product * f g a -> m

foldr :: (a -> b -> b) -> b -> Product * f g a -> b

foldr' :: (a -> b -> b) -> b -> Product * f g a -> b

foldl :: (b -> a -> b) -> b -> Product * f g a -> b

foldl' :: (b -> a -> b) -> b -> Product * f g a -> b

foldr1 :: (a -> a -> a) -> Product * f g a -> a

foldl1 :: (a -> a -> a) -> Product * f g a -> a

toList :: Product * f g a -> [a]

null :: Product * f g a -> Bool

length :: Product * f g a -> Int

elem :: Eq a => a -> Product * f g a -> Bool

maximum :: Ord a => Product * f g a -> a

minimum :: Ord a => Product * f g a -> a

sum :: Num a => Product * f g a -> a

product :: Num a => Product * f g a -> a

Traversable (K1 * i c)

Methods

traverse :: Applicative f => (a -> f b) -> K1 * i c a -> f (K1 * i c b)

sequenceA :: Applicative f => K1 * i c (f a) -> f (K1 * i c a)

mapM :: Monad m => (a -> m b) -> K1 * i c a -> m (K1 * i c b)

sequence :: Monad m => K1 * i c (m a) -> m (K1 * i c a)

(Traversable f, Traversable g) => Traversable ((:+:) * f g)

Methods

traverse :: Applicative f => (a -> f b) -> (* :+: f) g a -> f ((* :+: f) g b)

sequenceA :: Applicative f => (* :+: f) g (f a) -> f ((* :+: f) g a)

mapM :: Monad m => (a -> m b) -> (* :+: f) g a -> m ((* :+: f) g b)

sequence :: Monad m => (* :+: f) g (m a) -> m ((* :+: f) g a)

(Traversable f, Traversable g) => Traversable ((:*:) * f g)

Methods

traverse :: Applicative f => (a -> f b) -> (* :*: f) g a -> f ((* :*: f) g b)

sequenceA :: Applicative f => (* :*: f) g (f a) -> f ((* :*: f) g a)

mapM :: Monad m => (a -> m b) -> (* :*: f) g a -> m ((* :*: f) g b)

sequence :: Monad m => (* :*: f) g (m a) -> m ((* :*: f) g a)

(Traversable f, Traversable g) => Traversable (Sum * f g)

Since: 4.9.0.0

Methods

traverse :: Applicative f => (a -> f b) -> Sum * f g a -> f (Sum * f g b)

sequenceA :: Applicative f => Sum * f g (f a) -> f (Sum * f g a)

mapM :: Monad m => (a -> m b) -> Sum * f g a -> m (Sum * f g b)

sequence :: Monad m => Sum * f g (m a) -> m (Sum * f g a)

(Traversable f, Traversable g) => Traversable (Product * f g)

Since: 4.9.0.0

Methods

traverse :: Applicative f => (a -> f b) -> Product * f g a -> f (Product * f g b)

sequenceA :: Applicative f => Product * f g (f a) -> f (Product * f g a)

mapM :: Monad m => (a -> m b) -> Product * f g a -> m (Product * f g b)

sequence :: Monad m => Product * f g (m a) -> m (Product * f g a)

Alternative f => Semigroup (Alt * f a)

Since: 4.9.0.0

Methods

(<>) :: Alt * f a -> Alt * f a -> Alt * f a

sconcat :: NonEmpty (Alt * f a) -> Alt * f a

stimes :: Integral b => b -> Alt * f a -> Alt * f a

Alternative f => Monoid (Alt * f a)

Since: 4.8.0.0

Methods

mempty :: Alt * f a

mappend :: Alt * f a -> Alt * f a -> Alt * f a

mconcat :: [Alt * f a] -> Alt * f a

(MonadPlus f, MonadPlus g) => MonadPlus ((:*:) * f g)

Since: 4.9.0.0

Methods

mzero :: (* :*: f) g a

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

(MonadPlus f, MonadPlus g) => MonadPlus (Product * f g)

Since: 4.9.0.0

Methods

mzero :: Product * f g a

mplus :: Product * f g a -> Product * f g a -> Product * f g a

(Alternative f, Alternative g) => Alternative ((:*:) * f g)

Since: 4.9.0.0

Methods

empty :: (* :*: f) g a

(<|>) :: (* :*: f) g a -> (* :*: f) g a -> (* :*: f) g a

some :: (* :*: f) g a -> (* :*: f) g [a]

many :: (* :*: f) g a -> (* :*: f) g [a]

(Alternative f, Alternative g) => Alternative (Product * f g)

Since: 4.9.0.0

Methods

empty :: Product * f g a

(<|>) :: Product * f g a -> Product * f g a -> Product * f g a

some :: Product * f g a -> Product * f g [a]

many :: Product * f g a -> Product * f g [a]

(MonadZip f, MonadZip g) => MonadZip ((:*:) * f g)

Since: 4.9.0.0

Methods

mzip :: (* :*: f) g a -> (* :*: f) g b -> (* :*: f) g (a, b)

mzipWith :: (a -> b -> c) -> (* :*: f) g a -> (* :*: f) g b -> (* :*: f) g c

munzip :: (* :*: f) g (a, b) -> ((* :*: f) g a, (* :*: f) g b)

(MonadZip f, MonadZip g) => MonadZip (Product * f g)

Since: 4.9.0.0

Methods

mzip :: Product * f g a -> Product * f g b -> Product * f g (a, b)

mzipWith :: (a -> b -> c) -> Product * f g a -> Product * f g b -> Product * f g c

munzip :: Product * f g (a, b) -> (Product * f g a, Product * f g b)

(Show1 f, Show1 g) => Show1 (Sum * f g)

Since: 4.9.0.0

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Sum * f g a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Sum * f g a] -> ShowS

(Show1 f, Show1 g) => Show1 (Product * f g)

Since: 4.9.0.0

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Product * f g a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Product * f g a] -> ShowS

(Read1 f, Read1 g) => Read1 (Sum * f g)

Since: 4.9.0.0

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Sum * f g a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Sum * f g a]

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Sum * f g a)

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Sum * f g a]

(Read1 f, Read1 g) => Read1 (Product * f g)

Since: 4.9.0.0

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Product * f g a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Product * f g a]

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Product * f g a)

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Product * f g a]

(Ord1 f, Ord1 g) => Ord1 (Sum * f g)

Since: 4.9.0.0

Methods

liftCompare :: (a -> b -> Ordering) -> Sum * f g a -> Sum * f g b -> Ordering

(Ord1 f, Ord1 g) => Ord1 (Product * f g)

Since: 4.9.0.0

Methods

liftCompare :: (a -> b -> Ordering) -> Product * f g a -> Product * f g b -> Ordering

(Eq1 f, Eq1 g) => Eq1 (Sum * f g)

Since: 4.9.0.0

Methods

liftEq :: (a -> b -> Bool) -> Sum * f g a -> Sum * f g b -> Bool

(Eq1 f, Eq1 g) => Eq1 (Product * f g)

Since: 4.9.0.0

Methods

liftEq :: (a -> b -> Bool) -> Product * f g a -> Product * f g b -> Bool

(Eq1 f, Eq1 g, Eq a) => Eq (Sum * f g a)

Since: 4.9.0.0

Methods

(==) :: Sum * f g a -> Sum * f g a -> Bool

(/=) :: Sum * f g a -> Sum * f g a -> Bool

(Eq1 f, Eq1 g, Eq a) => Eq (Product * f g a)

Since: 4.9.0.0

Methods

(==) :: Product * f g a -> Product * f g a -> Bool

(/=) :: Product * f g a -> Product * f g a -> Bool

Monad f => Monad (M1 * i c f)

Since: 4.9.0.0

Methods

(>>=) :: M1 * i c f a -> (a -> M1 * i c f b) -> M1 * i c f b

(>>) :: M1 * i c f a -> M1 * i c f b -> M1 * i c f b

return :: a -> M1 * i c f a

fail :: String -> M1 * i c f a

(Typeable * i, Data p, Data c) => Data (K1 * i c p)

Since: 4.9.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> K1 * i c p -> c (K1 * i c p)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (K1 * i c p)

toConstr :: K1 * i c p -> Constr

dataTypeOf :: K1 * i c p -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (K1 * i c p))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (K1 * i c p))

gmapT :: (forall b. Data b => b -> b) -> K1 * i c p -> K1 * i c p

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> K1 * i c p -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> K1 * i c p -> r

gmapQ :: (forall d. Data d => d -> u) -> K1 * i c p -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> K1 * i c p -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> K1 * i c p -> m (K1 * i c p)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> K1 * i c p -> m (K1 * i c p)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> K1 * i c p -> m (K1 * i c p)

(Typeable (* -> *) f, Typeable (* -> *) g, Data p, Data (f p), Data (g p)) => Data ((:+:) * f g p)

Since: 4.9.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall a. a -> c a) -> (* :+: f) g p -> c ((* :+: f) g p)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ((* :+: f) g p)

toConstr :: (* :+: f) g p -> Constr

dataTypeOf :: (* :+: f) g p -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ((* :+: f) g p))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ((* :+: f) g p))

gmapT :: (forall b. Data b => b -> b) -> (* :+: f) g p -> (* :+: f) g p

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (* :+: f) g p -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (* :+: f) g p -> r

gmapQ :: (forall d. Data d => d -> u) -> (* :+: f) g p -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> (* :+: f) g p -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> (* :+: f) g p -> m ((* :+: f) g p)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (* :+: f) g p -> m ((* :+: f) g p)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (* :+: f) g p -> m ((* :+: f) g p)

(Typeable (* -> *) f, Typeable (* -> *) g, Data p, Data (f p), Data (g p)) => Data ((:*:) * f g p)

Since: 4.9.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall a. a -> c a) -> (* :*: f) g p -> c ((* :*: f) g p)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ((* :*: f) g p)

toConstr :: (* :*: f) g p -> Constr

dataTypeOf :: (* :*: f) g p -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ((* :*: f) g p))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ((* :*: f) g p))

gmapT :: (forall b. Data b => b -> b) -> (* :*: f) g p -> (* :*: f) g p

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (* :*: f) g p -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (* :*: f) g p -> r

gmapQ :: (forall d. Data d => d -> u) -> (* :*: f) g p -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> (* :*: f) g p -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> (* :*: f) g p -> m ((* :*: f) g p)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (* :*: f) g p -> m ((* :*: f) g p)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (* :*: f) g p -> m ((* :*: f) g p)

Functor f => Functor (M1 * i c f)

Methods

fmap :: (a -> b) -> M1 * i c f a -> M1 * i c f b

(<$) :: a -> M1 * i c f b -> M1 * i c f a

(Functor g, Functor f) => Functor ((:.:) * * f g)

Methods

fmap :: (a -> b) -> (* :.: *) f g a -> (* :.: *) f g b

(<$) :: a -> (* :.: *) f g b -> (* :.: *) f g a

(Functor f, Functor g) => Functor (Compose * * f g)

Since: 4.9.0.0

Methods

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

(<$) :: a -> Compose * * f g b -> Compose * * f g a

(Ord1 f, Ord1 g, Ord a) => Ord (Sum * f g a)

Since: 4.9.0.0

Methods

compare :: Sum * f g a -> Sum * f g a -> Ordering

(<) :: Sum * f g a -> Sum * f g a -> Bool

(<=) :: Sum * f g a -> Sum * f g a -> Bool

(>) :: Sum * f g a -> Sum * f g a -> Bool

(>=) :: Sum * f g a -> Sum * f g a -> Bool

max :: Sum * f g a -> Sum * f g a -> Sum * f g a

min :: Sum * f g a -> Sum * f g a -> Sum * f g a

(Ord1 f, Ord1 g, Ord a) => Ord (Product * f g a)

Since: 4.9.0.0

Methods

compare :: Product * f g a -> Product * f g a -> Ordering

(<) :: Product * f g a -> Product * f g a -> Bool

(<=) :: Product * f g a -> Product * f g a -> Bool

(>) :: Product * f g a -> Product * f g a -> Bool

(>=) :: Product * f g a -> Product * f g a -> Bool

max :: Product * f g a -> Product * f g a -> Product * f g a

min :: Product * f g a -> Product * f g a -> Product * f g a

(Read1 f, Read1 g, Read a) => Read (Sum * f g a)

Since: 4.9.0.0

Methods

readsPrec :: Int -> ReadS (Sum * f g a)

readList :: ReadS [Sum * f g a]

readPrec :: ReadPrec (Sum * f g a)

readListPrec :: ReadPrec [Sum * f g a]

(Read1 f, Read1 g, Read a) => Read (Product * f g a)

Since: 4.9.0.0

Methods

readsPrec :: Int -> ReadS (Product * f g a)

readList :: ReadS [Product * f g a]

readPrec :: ReadPrec (Product * f g a)

readListPrec :: ReadPrec [Product * f g a]

(Show1 f, Show1 g, Show a) => Show (Sum * f g a)

Since: 4.9.0.0

Methods

showsPrec :: Int -> Sum * f g a -> ShowS

show :: Sum * f g a -> String

showList :: [Sum * f g a] -> ShowS

(Show1 f, Show1 g, Show a) => Show (Product * f g a)

Since: 4.9.0.0

Methods

showsPrec :: Int -> Product * f g a -> ShowS

show :: Product * f g a -> String

showList :: [Product * f g a] -> ShowS

MonadFix f => MonadFix (M1 * i c f)

Since: 4.9.0.0

Methods

mfix :: (a -> M1 * i c f a) -> M1 * i c f a

Applicative f => Applicative (M1 * i c f)

Since: 4.9.0.0

Methods

pure :: a -> M1 * i c f a

(<*>) :: M1 * i c f (a -> b) -> M1 * i c f a -> M1 * i c f b

liftA2 :: (a -> b -> c) -> M1 * i c f a -> M1 * i c f b -> M1 * i c f c

(*>) :: M1 * i c f a -> M1 * i c f b -> M1 * i c f b

(<*) :: M1 * i c f a -> M1 * i c f b -> M1 * i c f a

(Applicative f, Applicative g) => Applicative ((:.:) * * f g)

Since: 4.9.0.0

Methods

pure :: a -> (* :.: *) f g a

(<*>) :: (* :.: *) f g (a -> b) -> (* :.: *) f g a -> (* :.: *) f g b

liftA2 :: (a -> b -> c) -> (* :.: *) f g a -> (* :.: *) f g b -> (* :.: *) f g c

(*>) :: (* :.: *) f g a -> (* :.: *) f g b -> (* :.: *) f g b

(<*) :: (* :.: *) f g a -> (* :.: *) f g b -> (* :.: *) f g a

(Applicative f, Applicative g) => Applicative (Compose * * f g)

Since: 4.9.0.0

Methods

pure :: a -> Compose * * f g a

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

liftA2 :: (a -> b -> c) -> Compose * * f g a -> Compose * * f g b -> Compose * * f g c

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

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

Foldable f => Foldable (M1 * i c f)

Methods

fold :: Monoid m => M1 * i c f m -> m

foldMap :: Monoid m => (a -> m) -> M1 * i c f a -> m

foldr :: (a -> b -> b) -> b -> M1 * i c f a -> b

foldr' :: (a -> b -> b) -> b -> M1 * i c f a -> b

foldl :: (b -> a -> b) -> b -> M1 * i c f a -> b

foldl' :: (b -> a -> b) -> b -> M1 * i c f a -> b

foldr1 :: (a -> a -> a) -> M1 * i c f a -> a

foldl1 :: (a -> a -> a) -> M1 * i c f a -> a

toList :: M1 * i c f a -> [a]

null :: M1 * i c f a -> Bool

length :: M1 * i c f a -> Int

elem :: Eq a => a -> M1 * i c f a -> Bool

maximum :: Ord a => M1 * i c f a -> a

minimum :: Ord a => M1 * i c f a -> a

sum :: Num a => M1 * i c f a -> a

product :: Num a => M1 * i c f a -> a

(Foldable f, Foldable g) => Foldable ((:.:) * * f g)

Methods

fold :: Monoid m => (* :.: *) f g m -> m

foldMap :: Monoid m => (a -> m) -> (* :.: *) f g a -> m

foldr :: (a -> b -> b) -> b -> (* :.: *) f g a -> b

foldr' :: (a -> b -> b) -> b -> (* :.: *) f g a -> b

foldl :: (b -> a -> b) -> b -> (* :.: *) f g a -> b

foldl' :: (b -> a -> b) -> b -> (* :.: *) f g a -> b

foldr1 :: (a -> a -> a) -> (* :.: *) f g a -> a

foldl1 :: (a -> a -> a) -> (* :.: *) f g a -> a

toList :: (* :.: *) f g a -> [a]

null :: (* :.: *) f g a -> Bool

length :: (* :.: *) f g a -> Int

elem :: Eq a => a -> (* :.: *) f g a -> Bool

maximum :: Ord a => (* :.: *) f g a -> a

minimum :: Ord a => (* :.: *) f g a -> a

sum :: Num a => (* :.: *) f g a -> a

product :: Num a => (* :.: *) f g a -> a

(Foldable f, Foldable g) => Foldable (Compose * * f g)

Since: 4.9.0.0

Methods

fold :: Monoid m => Compose * * f g m -> m

foldMap :: Monoid m => (a -> m) -> Compose * * f g a -> m

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

foldr' :: (a -> b -> b) -> b -> Compose * * f g a -> b

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

foldl' :: (b -> a -> b) -> b -> Compose * * f g a -> b

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

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

toList :: Compose * * f g a -> [a]

null :: Compose * * f g a -> Bool

length :: Compose * * f g a -> Int

elem :: Eq a => a -> Compose * * f g a -> Bool

maximum :: Ord a => Compose * * f g a -> a

minimum :: Ord a => Compose * * f g a -> a

sum :: Num a => Compose * * f g a -> a

product :: Num a => Compose * * f g a -> a

Traversable f => Traversable (M1 * i c f)

Methods

traverse :: Applicative f => (a -> f b) -> M1 * i c f a -> f (M1 * i c f b)

sequenceA :: Applicative f => M1 * i c f (f a) -> f (M1 * i c f a)

mapM :: Monad m => (a -> m b) -> M1 * i c f a -> m (M1 * i c f b)

sequence :: Monad m => M1 * i c f (m a) -> m (M1 * i c f a)

(Traversable f, Traversable g) => Traversable ((:.:) * * f g)

Methods

traverse :: Applicative f => (a -> f b) -> (* :.: *) f g a -> f ((* :.: *) f g b)

sequenceA :: Applicative f => (* :.: *) f g (f a) -> f ((* :.: *) f g a)

mapM :: Monad m => (a -> m b) -> (* :.: *) f g a -> m ((* :.: *) f g b)

sequence :: Monad m => (* :.: *) f g (m a) -> m ((* :.: *) f g a)

(Traversable f, Traversable g) => Traversable (Compose * * f g)

Since: 4.9.0.0

Methods

traverse :: Applicative f => (a -> f b) -> Compose * * f g a -> f (Compose * * f g b)

sequenceA :: Applicative f => Compose * * f g (f a) -> f (Compose * * f g a)

mapM :: Monad m => (a -> m b) -> Compose * * f g a -> m (Compose * * f g b)

sequence :: Monad m => Compose * * f g (m a) -> m (Compose * * f g a)

MonadPlus f => MonadPlus (M1 * i c f)

Since: 4.9.0.0

Methods

mzero :: M1 * i c f a

mplus :: M1 * i c f a -> M1 * i c f a -> M1 * i c f a

Alternative f => Alternative (M1 * i c f)

Since: 4.9.0.0

Methods

empty :: M1 * i c f a

(<|>) :: M1 * i c f a -> M1 * i c f a -> M1 * i c f a

some :: M1 * i c f a -> M1 * i c f [a]

many :: M1 * i c f a -> M1 * i c f [a]

(Alternative f, Applicative g) => Alternative ((:.:) * * f g)

Since: 4.9.0.0

Methods

empty :: (* :.: *) f g a

(<|>) :: (* :.: *) f g a -> (* :.: *) f g a -> (* :.: *) f g a

some :: (* :.: *) f g a -> (* :.: *) f g [a]

many :: (* :.: *) f g a -> (* :.: *) f g [a]

(Alternative f, Applicative g) => Alternative (Compose * * f g)

Since: 4.9.0.0

Methods

empty :: Compose * * f g a

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

some :: Compose * * f g a -> Compose * * f g [a]

many :: Compose * * f g a -> Compose * * f g [a]

MonadZip f => MonadZip (M1 * i c f)

Since: 4.9.0.0

Methods

mzip :: M1 * i c f a -> M1 * i c f b -> M1 * i c f (a, b)

mzipWith :: (a -> b -> c) -> M1 * i c f a -> M1 * i c f b -> M1 * i c f c

munzip :: M1 * i c f (a, b) -> (M1 * i c f a, M1 * i c f b)

(Show1 f, Show1 g) => Show1 (Compose * * f g)

Since: 4.9.0.0

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Compose * * f g a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Compose * * f g a] -> ShowS

(Read1 f, Read1 g) => Read1 (Compose * * f g)

Since: 4.9.0.0

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Compose * * f g a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Compose * * f g a]

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Compose * * f g a)

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Compose * * f g a]

(Ord1 f, Ord1 g) => Ord1 (Compose * * f g)

Since: 4.9.0.0

Methods

liftCompare :: (a -> b -> Ordering) -> Compose * * f g a -> Compose * * f g b -> Ordering

(Eq1 f, Eq1 g) => Eq1 (Compose * * f g)

Since: 4.9.0.0

Methods

liftEq :: (a -> b -> Bool) -> Compose * * f g a -> Compose * * f g b -> Bool

(Eq1 f, Eq1 g, Eq a) => Eq (Compose * * f g a)

Since: 4.9.0.0

Methods

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

(/=) :: Compose * * f g a -> Compose * * f g a -> Bool

(Data p, Data (f p), Typeable Meta c, Typeable * i, Typeable (* -> *) f) => Data (M1 * i c f p)

Since: 4.9.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> M1 * i c f p -> c (M1 * i c f p)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (M1 * i c f p)

toConstr :: M1 * i c f p -> Constr

dataTypeOf :: M1 * i c f p -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (M1 * i c f p))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (M1 * i c f p))

gmapT :: (forall b. Data b => b -> b) -> M1 * i c f p -> M1 * i c f p

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> M1 * i c f p -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> M1 * i c f p -> r

gmapQ :: (forall d. Data d => d -> u) -> M1 * i c f p -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> M1 * i c f p -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> M1 * i c f p -> m (M1 * i c f p)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> M1 * i c f p -> m (M1 * i c f p)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> M1 * i c f p -> m (M1 * i c f p)

(Typeable (* -> *) f, Typeable (* -> *) g, Data p, Data (f (g p))) => Data ((:.:) * * f g p)

Since: 4.9.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall a. a -> c a) -> (* :.: *) f g p -> c ((* :.: *) f g p)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ((* :.: *) f g p)

toConstr :: (* :.: *) f g p -> Constr

dataTypeOf :: (* :.: *) f g p -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ((* :.: *) f g p))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ((* :.: *) f g p))

gmapT :: (forall b. Data b => b -> b) -> (* :.: *) f g p -> (* :.: *) f g p

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (* :.: *) f g p -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (* :.: *) f g p -> r

gmapQ :: (forall d. Data d => d -> u) -> (* :.: *) f g p -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> (* :.: *) f g p -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> (* :.: *) f g p -> m ((* :.: *) f g p)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (* :.: *) f g p -> m ((* :.: *) f g p)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (* :.: *) f g p -> m ((* :.: *) f g p)

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

Since: 4.9.0.0

Methods

compare :: Compose * * f g a -> Compose * * f g a -> Ordering

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

(<=) :: Compose * * f g a -> Compose * * f g a -> Bool

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

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

max :: Compose * * f g a -> Compose * * f g a -> Compose * * f g a

min :: Compose * * f g a -> Compose * * f g a -> Compose * * f g a

(Read1 f, Read1 g, Read a) => Read (Compose * * f g a)

Since: 4.9.0.0

Methods

readsPrec :: Int -> ReadS (Compose * * f g a)

readList :: ReadS [Compose * * f g a]

readPrec :: ReadPrec (Compose * * f g a)

readListPrec :: ReadPrec [Compose * * f g a]

(Show1 f, Show1 g, Show a) => Show (Compose * * f g a)

Since: 4.9.0.0

Methods

showsPrec :: Int -> Compose * * f g a -> ShowS

show :: Compose * * f g a -> String

showList :: [Compose * * f g a] -> ShowS

type (==) * a b

type (==) * a b

type Rep1 k ((:.:) * k f g)

type Rep1 k ((:.:) * k f g) = D1 k (MetaData ":.:" "GHC.Generics" "base" True) (C1 k (MetaCons "Comp1" PrefixI True) (S1 k (MetaSel (Just Symbol "unComp1") NoSourceUnpackedness NoSourceStrictness DecidedLazy) ((:.:) * k f (Rec1 k g))))

type Rep1 k (Compose * k f g)

type Rep1 k (Compose * k f g) = D1 k (MetaData "Compose" "Data.Functor.Compose" "base" True) (C1 k (MetaCons "Compose" PrefixI True) (S1 k (MetaSel (Just Symbol "getCompose") NoSourceUnpackedness NoSourceStrictness DecidedLazy) ((:.:) * k f (Rec1 k g))))

type Rep1 * []

type Rep1 * [] = D1 * (MetaData "[]" "GHC.Types" "ghc-prim" False) ((:+:) * (C1 * (MetaCons "[]" PrefixI False) (U1 *)) (C1 * (MetaCons ":" (InfixI LeftAssociative 9) False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 * [])))))

type Rep1 * Maybe

type Rep1 * Maybe = D1 * (MetaData "Maybe" "GHC.Base" "base" False) ((:+:) * (C1 * (MetaCons "Nothing" PrefixI False) (U1 *)) (C1 * (MetaCons "Just" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1)))

type Rep1 * Par1

type Rep1 * Par1 = D1 * (MetaData "Par1" "GHC.Generics" "base" True) (C1 * (MetaCons "Par1" PrefixI True) (S1 * (MetaSel (Just Symbol "unPar1") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

type Rep1 * Last

type Rep1 * Last = D1 * (MetaData "Last" "Data.Monoid" "base" True) (C1 * (MetaCons "Last" PrefixI True) (S1 * (MetaSel (Just Symbol "getLast") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 * Maybe)))

type Rep1 * First

type Rep1 * First = D1 * (MetaData "First" "Data.Monoid" "base" True) (C1 * (MetaCons "First" PrefixI True) (S1 * (MetaSel (Just Symbol "getFirst") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 * Maybe)))

type Rep1 * Product

type Rep1 * Product = D1 * (MetaData "Product" "Data.Monoid" "base" True) (C1 * (MetaCons "Product" PrefixI True) (S1 * (MetaSel (Just Symbol "getProduct") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

type Rep1 * Sum

type Rep1 * Sum = D1 * (MetaData "Sum" "Data.Monoid" "base" True) (C1 * (MetaCons "Sum" PrefixI True) (S1 * (MetaSel (Just Symbol "getSum") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

type Rep1 * Dual

type Rep1 * Dual = D1 * (MetaData "Dual" "Data.Monoid" "base" True) (C1 * (MetaCons "Dual" PrefixI True) (S1 * (MetaSel (Just Symbol "getDual") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

type Rep1 * Identity

type Rep1 * Identity = D1 * (MetaData "Identity" "Data.Functor.Identity" "base" True) (C1 * (MetaCons "Identity" PrefixI True) (S1 * (MetaSel (Just Symbol "runIdentity") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

type Rep1 * ZipList

type Rep1 * ZipList = D1 * (MetaData "ZipList" "Control.Applicative" "base" True) (C1 * (MetaCons "ZipList" PrefixI True) (S1 * (MetaSel (Just Symbol "getZipList") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 * [])))

type Rep1 * NonEmpty

type Rep1 * NonEmpty = D1 * (MetaData "NonEmpty" "Data.List.NonEmpty" "base" False) (C1 * (MetaCons ":|" (InfixI RightAssociative 5) False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 * []))))

type Rep1 * Option

type Rep1 * Option = D1 * (MetaData "Option" "Data.Semigroup" "base" True) (C1 * (MetaCons "Option" PrefixI True) (S1 * (MetaSel (Just Symbol "getOption") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 * Maybe)))

type Rep1 * WrappedMonoid

type Rep1 * WrappedMonoid = D1 * (MetaData "WrappedMonoid" "Data.Semigroup" "base" True) (C1 * (MetaCons "WrapMonoid" PrefixI True) (S1 * (MetaSel (Just Symbol "unwrapMonoid") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

type Rep1 * Last

type Rep1 * Last = D1 * (MetaData "Last" "Data.Semigroup" "base" True) (C1 * (MetaCons "Last" PrefixI True) (S1 * (MetaSel (Just Symbol "getLast") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

type Rep1 * First

type Rep1 * First = D1 * (MetaData "First" "Data.Semigroup" "base" True) (C1 * (MetaCons "First" PrefixI True) (S1 * (MetaSel (Just Symbol "getFirst") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

type Rep1 * Max

type Rep1 * Max = D1 * (MetaData "Max" "Data.Semigroup" "base" True) (C1 * (MetaCons "Max" PrefixI True) (S1 * (MetaSel (Just Symbol "getMax") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

type Rep1 * Min

type Rep1 * Min = D1 * (MetaData "Min" "Data.Semigroup" "base" True) (C1 * (MetaCons "Min" PrefixI True) (S1 * (MetaSel (Just Symbol "getMin") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

type Rep1 * Complex

type Rep1 * Complex = D1 * (MetaData "Complex" "Data.Complex" "base" False) (C1 * (MetaCons ":+" (InfixI NotAssociative 6) False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) Par1) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) Par1)))

type Rep1 * (Either a)

type Rep1 * (Either a) = D1 * (MetaData "Either" "Data.Either" "base" False) ((:+:) * (C1 * (MetaCons "Left" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a))) (C1 * (MetaCons "Right" PrefixI False) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1)))

type Rep1 * ((,) a)

type Rep1 * ((,) a) = D1 * (MetaData "(,)" "GHC.Tuple" "ghc-prim" False) (C1 * (MetaCons "(,)" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1)))

type Rep1 * (WrappedMonad m)

type Rep1 * (WrappedMonad m) = D1 * (MetaData "WrappedMonad" "Control.Applicative" "base" True) (C1 * (MetaCons "WrapMonad" PrefixI True) (S1 * (MetaSel (Just Symbol "unwrapMonad") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 * m)))

type Rep1 * (Arg a)

type Rep1 * (Arg a) = D1 * (MetaData "Arg" "Data.Semigroup" "base" False) (C1 * (MetaCons "Arg" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1)))

type Rep1 * ((,,) a b)

type Rep1 * ((,,) a b) = D1 * (MetaData "(,,)" "GHC.Tuple" "ghc-prim" False) (C1 * (MetaCons "(,,)" PrefixI False) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * b)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))))

type Rep1 * (WrappedArrow a b)

type Rep1 * (WrappedArrow a b) = D1 * (MetaData "WrappedArrow" "Control.Applicative" "base" True) (C1 * (MetaCons "WrapArrow" PrefixI True) (S1 * (MetaSel (Just Symbol "unwrapArrow") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 * (a b))))

type Rep1 * ((,,,) a b c)

type Rep1 * ((,,,) a b c) = D1 * (MetaData "(,,,)" "GHC.Tuple" "ghc-prim" False) (C1 * (MetaCons "(,,,)" PrefixI False) ((:*:) * ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * b))) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * c)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))))

type Rep1 * ((,,,,) a b c d)

type Rep1 * ((,,,,) a b c d) = D1 * (MetaData "(,,,,)" "GHC.Tuple" "ghc-prim" False) (C1 * (MetaCons "(,,,,)" PrefixI False) ((:*:) * ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * b))) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * c)) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * d)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1)))))

type Rep1 * ((,,,,,) a b c d e)

type Rep1 * ((,,,,,) a b c d e) = D1 * (MetaData "(,,,,,)" "GHC.Tuple" "ghc-prim" False) (C1 * (MetaCons "(,,,,,)" PrefixI False) ((:*:) * ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * b)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * c)))) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * d)) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * e)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1)))))

type Rep1 * ((,,,,,,) a b c d e f)

type Rep1 * ((,,,,,,) a b c d e f) = D1 * (MetaData "(,,,,,,)" "GHC.Tuple" "ghc-prim" False) (C1 * (MetaCons "(,,,,,,)" PrefixI False) ((:*:) * ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * b)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * c)))) ((:*:) * ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * d)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * e))) ((:*:) * (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * f)) (S1 * (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1)))))

data RuntimeRep :: *

GHC maintains a property that the kind of all inhabited types (as distinct from type constructors or type-level data) tells us the runtime representation of values of that type. This datatype encodes the choice of runtime value. Note that TYPE is parameterised by RuntimeRep; this is precisely what we mean by the fact that a type's kind encodes the runtime representation.

For boxed values (that is, values that are represented by a pointer), a further distinction is made, between lifted types (that contain ⊥), and unlifted ones (that don't).

Constructors

VecRep VecCount VecElem

a SIMD vector type

TupleRep [RuntimeRep]

An unboxed tuple of the given reps

SumRep [RuntimeRep]

An unboxed sum of the given reps

LiftedRep

lifted; represented by a pointer

UnliftedRep

unlifted; represented by a pointer

IntRep

signed, word-sized value

WordRep

unsigned, word-sized value

Int64Rep

signed, 64-bit value (on 32-bit only)

Word64Rep

unsigned, 64-bit value (on 32-bit only)

AddrRep

A pointer, but not to a Haskell value

FloatRep

a 32-bit floating point number

DoubleRep

a 64-bit floating point number

data VecCount :: *

Length of a SIMD vector type

Constructors

Vec2

Vec4

Vec8

Vec16

Vec32

Vec64

Instances

Bounded VecCount

Since: 4.10.0.0

Methods

minBound :: VecCount

maxBound :: VecCount

Enum VecCount

Since: 4.10.0.0

Methods

succ :: VecCount -> VecCount

pred :: VecCount -> VecCount

toEnum :: Int -> VecCount

fromEnum :: VecCount -> Int

enumFrom :: VecCount -> [VecCount]

enumFromThen :: VecCount -> VecCount -> [VecCount]

enumFromTo :: VecCount -> VecCount -> [VecCount]

enumFromThenTo :: VecCount -> VecCount -> VecCount -> [VecCount]

data VecElem :: *

Element of a SIMD vector type

Constructors

Int8ElemRep

Int16ElemRep

Int32ElemRep

Int64ElemRep

Word8ElemRep

Word16ElemRep

Word32ElemRep

Word64ElemRep

FloatElemRep

DoubleElemRep

Instances

Bounded VecElem

Since: 4.10.0.0

Methods

minBound :: VecElem

maxBound :: VecElem

Enum VecElem

Since: 4.10.0.0

Methods

succ :: VecElem -> VecElem

pred :: VecElem -> VecElem

toEnum :: Int -> VecElem

fromEnum :: VecElem -> Int

enumFrom :: VecElem -> [VecElem]

enumFromThen :: VecElem -> VecElem -> [VecElem]

enumFromTo :: VecElem -> VecElem -> [VecElem]

enumFromThenTo :: VecElem -> VecElem -> VecElem -> [VecElem]

Transform comprehensions

newtype Down a

The Down type allows you to reverse sort order conveniently. A value of type Down a contains a value of type a (represented as Down a). If a has an Ord instance associated with it then comparing two values thus wrapped will give you the opposite of their normal sort order. This is particularly useful when sorting in generalised list comprehensions, as in: then sortWith by Down x

Provides Show and Read instances (since: 4.7.0.0).

Since: 4.6.0.0

Constructors

Down a

Instances

Eq a => Eq (Down a)

Methods

(==) :: Down a -> Down a -> Bool

(/=) :: Down a -> Down a -> Bool

Ord a => Ord (Down a)

Since: 4.6.0.0

Methods

compare :: Down a -> Down a -> Ordering

(<) :: Down a -> Down a -> Bool

(<=) :: Down a -> Down a -> Bool

(>) :: Down a -> Down a -> Bool

(>=) :: Down a -> Down a -> Bool

max :: Down a -> Down a -> Down a

min :: Down a -> Down a -> Down a

Read a => Read (Down a)

Methods

readsPrec :: Int -> ReadS (Down a)

readList :: ReadS [Down a]

readPrec :: ReadPrec (Down a)

readListPrec :: ReadPrec [Down a]

Show a => Show (Down a)

Methods

showsPrec :: Int -> Down a -> ShowS

show :: Down a -> String

showList :: [Down a] -> ShowS

groupWith :: Ord b => (a -> b) -> [a] -> [[a]]

The groupWith function uses the user supplied function which projects an element out of every list element in order to first sort the input list and then to form groups by equality on these projected elements

sortWith :: Ord b => (a -> b) -> [a] -> [a]

The sortWith function sorts a list of elements using the user supplied function to project something out of each element

the :: Eq a => [a] -> a

the ensures that all the elements of the list are identical and then returns that unique element

Event logging

traceEvent :: String -> IO ()

Deprecated: Use traceEvent or traceEventIO

SpecConstr annotations

data SpecConstrAnnotation

Constructors

NoSpecConstr

ForceSpecConstr

Instances

Eq SpecConstrAnnotation

Methods

(==) :: SpecConstrAnnotation -> SpecConstrAnnotation -> Bool

(/=) :: SpecConstrAnnotation -> SpecConstrAnnotation -> Bool

Data SpecConstrAnnotation

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SpecConstrAnnotation -> c SpecConstrAnnotation

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SpecConstrAnnotation

toConstr :: SpecConstrAnnotation -> Constr

dataTypeOf :: SpecConstrAnnotation -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c SpecConstrAnnotation)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SpecConstrAnnotation)

gmapT :: (forall b. Data b => b -> b) -> SpecConstrAnnotation -> SpecConstrAnnotation

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SpecConstrAnnotation -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SpecConstrAnnotation -> r

gmapQ :: (forall d. Data d => d -> u) -> SpecConstrAnnotation -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> SpecConstrAnnotation -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SpecConstrAnnotation -> m SpecConstrAnnotation

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SpecConstrAnnotation -> m SpecConstrAnnotation

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SpecConstrAnnotation -> m SpecConstrAnnotation

The call stack

currentCallStack :: IO [String]

Returns a [String] representing the current call stack. This can be useful for debugging.

The implementation uses the call-stack simulation maintained by the profiler, so it only works if the program was compiled with -prof and contains suitable SCC annotations (e.g. by using -fprof-auto). Otherwise, the list returned is likely to be empty or uninformative.

Since: 4.5.0.0

The Constraint kind

data Constraint :: *

The kind of constraints, like Show a

The Any type

type family Any k0 :: k0 where ...

The type constructor Any is type to which you can unsafely coerce any lifted type, and back. More concretely, for a lifted type t and value x :: t, -- unsafeCoerce (unsafeCoerce x :: Any) :: t is equivalent to x.

Overloaded lists

class IsList l where

The IsList class and its methods are intended to be used in conjunction with the OverloadedLists extension.

Since: 4.7.0.0

Minimal complete definition

fromList, toList

Associated Types

type Item l

The Item type function returns the type of items of the structure l.

Methods

fromList :: [Item l] -> l

The fromList function constructs the structure l from the given list of Item l

fromListN :: Int -> [Item l] -> l

The fromListN function takes the input list's length as a hint. Its behaviour should be equivalent to fromList. The hint can be used to construct the structure l more efficiently compared to fromList. If the given hint does not equal to the input list's length the behaviour of fromListN is not specified.

toList :: l -> [Item l]

The toList function extracts a list of Item l from the structure l. It should satisfy fromList . toList = id.

Instances

IsList CallStack

Be aware that 'fromList . toList = id' only for unfrozen CallStacks, since toList removes frozenness information.

Since: 4.9.0.0

Associated Types

type Item CallStack :: *

Methods

fromList :: [Item CallStack] -> CallStack

fromListN :: Int -> [Item CallStack] -> CallStack

toList :: CallStack -> [Item CallStack]

IsList Version

Since: 4.8.0.0

Associated Types

type Item Version :: *

Methods

fromList :: [Item Version] -> Version

fromListN :: Int -> [Item Version] -> Version

toList :: Version -> [Item Version]

IsList [a]

Since: 4.7.0.0

Associated Types

type Item [a] :: *

Methods

fromList :: [Item [a]] -> [a]

fromListN :: Int -> [Item [a]] -> [a]

toList :: [a] -> [Item [a]]

IsList (NonEmpty a)

Since: 4.9.0.0

Associated Types

type Item (NonEmpty a) :: *

Methods

fromList :: [Item (NonEmpty a)] -> NonEmpty a

fromListN :: Int -> [Item (NonEmpty a)] -> NonEmpty a

toList :: NonEmpty a -> [Item (NonEmpty a)]