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

Methods

minBound :: Int

maxBound :: Int

Enum Int

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

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

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

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

Methods

readsPrec :: Int -> ReadS Int

readList :: ReadS [Int]

readPrec :: ReadPrec Int

readListPrec :: ReadPrec [Int]

Real Int

Methods

toRational :: Int -> Rational

Show Int

Methods

showsPrec :: Int -> Int -> ShowS

show :: Int -> String

showList :: [Int] -> ShowS

Ix Int

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

Methods

finiteBitSize :: Int -> Int

countLeadingZeros :: Int -> Int

countTrailingZeros :: Int -> Int

Bits Int

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

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

Methods

formatArg :: Int -> FieldFormatter

parseFormat :: Int -> ModifierParser

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)

Generic1 (URec Int)

Associated Types

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

Methods

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

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

Eq (URec Int p)

Methods

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

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

Ord (URec Int p)

Methods

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

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

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

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

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

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

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

Show (URec Int p)

Methods

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

show :: URec Int p -> String

showList :: [URec Int p] -> ShowS

Generic (URec Int p)

Associated Types

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

Methods

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

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

data URec Int

Used for marking occurrences of Int#

data URec Int = UInt {

• uInt# :: Int#

}

type Rep1 (URec Int)

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

type Rep (URec Int p)

type Rep (URec 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

Methods

minBound :: Word

maxBound :: Word

Enum Word

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

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

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

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

Methods

readsPrec :: Int -> ReadS Word

readList :: ReadS [Word]

readPrec :: ReadPrec Word

readListPrec :: ReadPrec [Word]

Real Word

Methods

toRational :: Word -> Rational

Show Word

Methods

showsPrec :: Int -> Word -> ShowS

show :: Word -> String

showList :: [Word] -> ShowS

Ix Word

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

Methods

finiteBitSize :: Word -> Int

countLeadingZeros :: Word -> Int

countTrailingZeros :: Word -> Int

Bits Word

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

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

Methods

formatArg :: Word -> FieldFormatter

parseFormat :: Word -> ModifierParser

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)

Generic1 (URec Word)

Associated Types

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

Methods

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

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

Eq (URec Word p)

Methods

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

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

Ord (URec Word p)

Methods

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

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

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

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

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

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

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

Show (URec Word p)

Methods

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

show :: URec Word p -> String

showList :: [URec Word p] -> ShowS

Generic (URec Word p)

Associated Types

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

Methods

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

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

data URec Word

Used for marking occurrences of Word#

data URec Word = UWord {

• uWord# :: Word#

}

type Rep1 (URec Word)

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

type Rep (URec Word p)

type Rep (URec 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

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

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

Methods

readsPrec :: Int -> ReadS Float

readList :: ReadS [Float]

readPrec :: ReadPrec Float

readListPrec :: ReadPrec [Float]

RealFloat Float

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

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

Methods

formatArg :: Float -> FieldFormatter

parseFormat :: Float -> ModifierParser

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)

Generic1 (URec Float)

Associated Types

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

Methods

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

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

Eq (URec Float p)

Methods

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

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

Ord (URec Float p)

Methods

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

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

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

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

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

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

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

Show (URec Float p)

Methods

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

show :: URec Float p -> String

showList :: [URec Float p] -> ShowS

Generic (URec Float p)

Associated Types

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

Methods

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

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

data URec Float

Used for marking occurrences of Float#

data URec Float = UFloat {

• uFloat# :: Float#

}

type Rep1 (URec Float)

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

type Rep (URec Float p)

type Rep (URec 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

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

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

Methods

readsPrec :: Int -> ReadS Double

readList :: ReadS [Double]

readPrec :: ReadPrec Double

readListPrec :: ReadPrec [Double]

RealFloat Double

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

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

Methods

formatArg :: Double -> FieldFormatter

parseFormat :: Double -> ModifierParser

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)

Generic1 (URec Double)

Associated Types

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

Methods

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

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

Eq (URec Double p)

Methods

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

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

Ord (URec Double p)

Methods

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

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

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

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

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

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

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

Show (URec Double p)

Methods

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

show :: URec Double p -> String

showList :: [URec Double p] -> ShowS

Generic (URec Double p)

Associated Types

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

Methods

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

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

data URec Double

Used for marking occurrences of Double#

data URec Double = UDouble {

• uDouble# :: Double#

}

type Rep1 (URec Double)

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

type Rep (URec Double p)

type Rep (URec 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

Methods

minBound :: Char

maxBound :: Char

Enum Char

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

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

Methods

readsPrec :: Int -> ReadS Char

readList :: ReadS [Char]

readPrec :: ReadPrec Char

readListPrec :: ReadPrec [Char]

Show Char

Methods

showsPrec :: Int -> Char -> ShowS

show :: Char -> String

showList :: [Char] -> ShowS

Ix Char

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

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

Methods

toChar :: Char -> Char

fromChar :: Char -> Char

PrintfArg Char

Methods

formatArg :: Char -> FieldFormatter

parseFormat :: Char -> ModifierParser

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)

Generic1 (URec Char)

Associated Types

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

Methods

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

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

Eq (URec Char p)

Methods

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

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

Ord (URec Char p)

Methods

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

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

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

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

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

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

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

Show (URec Char p)

Methods

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

show :: URec Char p -> String

showList :: [URec Char p] -> ShowS

Generic (URec Char p)

Associated Types

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

Methods

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

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

data URec Char

Used for marking occurrences of Char#

data URec Char = UChar {

• uChar# :: Char#

}

type Rep1 (URec Char)

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

type Rep (URec Char p)

type Rep (URec 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

Eq (Ptr a)

Methods

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

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

Data a => Data (Ptr a)

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)

Functor (URec (Ptr ()))

Methods

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

(<$) :: a -> URec (Ptr ()) b -> URec (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)

Methods

showsPrec :: Int -> Ptr a -> ShowS

show :: Ptr a -> String

showList :: [Ptr a] -> ShowS

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)

Generic1 (URec (Ptr ()))

Associated Types

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

Methods

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

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

Storable (Ptr a)

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 ()

Eq (URec (Ptr ()) p)

Methods

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

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

Ord (URec (Ptr ()) p)

Methods

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

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

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

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

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

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

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

Generic (URec (Ptr ()) p)

Associated Types

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

Methods

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

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

type Rep1 (URec (Ptr ()))

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

data URec (Ptr ())

Used for marking occurrences of Addr#

data URec (Ptr ()) = UAddr {

• uAddr# :: Addr#

}

type Rep (URec (Ptr ()) p)

type Rep (URec (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)

Methods

showsPrec :: Int -> FunPtr a -> ShowS

show :: FunPtr a -> String

showList :: [FunPtr a] -> ShowS

Storable (FunPtr a)

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]

Methods

fromString :: String -> [a]

IsString a => IsString (Identity a)

Methods

fromString :: String -> Identity a

IsString a => IsString (Const * a b)

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.

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#) k k a b => Coercible k a b

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 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 (~#) j k a b => (j ~~ k) a b

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 -> *

Instances

Monad (Proxy *)

Methods

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

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

return :: a -> Proxy * a

fail :: String -> Proxy * a

Functor (Proxy *)

Methods

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

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

Applicative (Proxy *)

Methods

pure :: a -> Proxy * a

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

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

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

Foldable (Proxy *)

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 (Proxy *)

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)

Generic1 (Proxy *)

Associated Types

type Rep1 (Proxy * :: * -> *) :: * -> *

Methods

from1 :: Proxy * a -> Rep1 (Proxy *) a

to1 :: Rep1 (Proxy *) a -> Proxy * a

MonadPlus (Proxy *)

Methods

mzero :: Proxy * a

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

Alternative (Proxy *)

Methods

empty :: Proxy * a

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

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

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

MonadZip (Proxy *)

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)

Bifunctor (Const *)

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

Show2 (Const *)

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 *)

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]

Ord2 (Const *)

Methods

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

Eq2 (Const *)

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]

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

Category * (->)

Methods

id :: cat a a

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

Monad m => Category * (Kleisli m)

Methods

id :: cat a a

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

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 t => Data (Proxy * t)

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 (Alt * f)

Methods

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

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

Functor (Const * m)

Methods

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

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

MonadFix f => MonadFix (Alt * f)

Methods

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

Applicative f => Applicative (Alt * f)

Methods

pure :: a -> Alt * f a

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

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

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

Monoid m => Applicative (Const * m)

Methods

pure :: a -> Const * m a

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

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

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

Foldable (Const * m)

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 (Const * m)

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)

Generic1 (Alt * f)

Associated Types

type Rep1 (Alt * f :: * -> *) :: * -> *

Methods

from1 :: Alt * f a -> Rep1 (Alt * f) a

to1 :: Rep1 (Alt * f) a -> Alt * f a

Generic1 (Const * a)

Associated Types

type Rep1 (Const * a :: * -> *) :: * -> *

Methods

from1 :: Const * a a -> Rep1 (Const * a) a

to1 :: Rep1 (Const * a) a -> Const * a a

MonadPlus f => MonadPlus (Alt * f)

Methods

mzero :: Alt * f a

mplus :: Alt * f a -> Alt * f a -> Alt * 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 (Alt * f)

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)

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)

Methods

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

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

Ord a => Ord1 (Const * a)

Methods

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

Eq a => Eq1 (Const * a)

Methods

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

(Monad f, Monad g) => Monad (Product * f g)

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

((~) * a b, Data a) => Data ((:~:) * a b)

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)

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)

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 f, Functor g) => Functor (Product * f g)

Methods

fmap :: (a -> b) -> Product * f g a -> Product * f g b

(<$) :: a -> Product * f g b -> Product * f g a

(Functor f, Functor g) => Functor (Sum * f g)

Methods

fmap :: (a -> b) -> Sum * f g a -> Sum * f g b

(<$) :: a -> Sum * f g b -> Sum * f g a

(MonadFix f, MonadFix g) => MonadFix (Product * f g)

Methods

mfix :: (a -> Product * f g a) -> Product * f g a

IsString a => IsString (Const * a b)

Methods

fromString :: String -> Const * a b

(Applicative f, Applicative g) => Applicative (Product * f g)

Methods

pure :: a -> Product * f g a

(<*>) :: Product * f g (a -> b) -> Product * f g a -> Product * f g b

(*>) :: 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 f, Foldable g) => Foldable (Product * f g)

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

(Foldable f, Foldable g) => Foldable (Sum * f g)

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

(Traversable f, Traversable g) => Traversable (Product * f g)

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)

(Traversable f, Traversable g) => Traversable (Sum * f g)

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)

Generic1 (Product * f g)

Associated Types

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

Methods

from1 :: Product * f g a -> Rep1 (Product * f g) a

to1 :: Rep1 (Product * f g) a -> Product * f g a

Generic1 (Sum * f g)

Associated Types

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

Methods

from1 :: Sum * f g a -> Rep1 (Sum * f g) a

to1 :: Rep1 (Sum * f g) a -> Sum * f g a

Alternative f => Semigroup (Alt * f a)

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)

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 (Product * f g)

Methods

mzero :: Product * f g a

mplus :: Product * f g a -> Product * f g a -> Product * f g a

(Alternative f, Alternative g) => Alternative (Product * f g)

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 (Product * f g)

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 (Product * f g)

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Product * f g a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Product * f g a] -> ShowS

(Show1 f, Show1 g) => Show1 (Sum * f g)

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Sum * f g a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Sum * f g a] -> ShowS

(Read1 f, Read1 g) => Read1 (Product * f g)

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Product * f g a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Product * f g a]

(Read1 f, Read1 g) => Read1 (Sum * f g)

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Sum * f g a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Sum * f g a]

(Ord1 f, Ord1 g) => Ord1 (Product * f g)

Methods

liftCompare :: (a -> b -> Ordering) -> Product * f g a -> Product * f g b -> Ordering

(Ord1 f, Ord1 g) => Ord1 (Sum * f g)

Methods

liftCompare :: (a -> b -> Ordering) -> Sum * f g a -> Sum * f g b -> Ordering

(Eq1 f, Eq1 g) => Eq1 (Product * f g)

Methods

liftEq :: (a -> b -> Bool) -> Product * f g a -> Product * f g b -> Bool

(Eq1 f, Eq1 g) => Eq1 (Sum * f g)

Methods

liftEq :: (a -> b -> Bool) -> Sum * f g a -> Sum * f g b -> Bool

(Eq1 f, Eq1 g, Eq a) => Eq (Product * f g a)

Methods

(==) :: Product * f g a -> Product * f g a -> Bool

(/=) :: Product * f g a -> Product * f g a -> Bool

(Eq1 f, Eq1 g, Eq a) => Eq (Sum * f g a)

Methods

(==) :: Sum * f g a -> Sum * f g a -> Bool

(/=) :: Sum * f g a -> Sum * f g a -> Bool

(Functor f, Functor g) => Functor (Compose * * f g)

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 (Product * f g a)

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

(Ord1 f, Ord1 g, Ord a) => Ord (Sum * f g a)

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

(Read1 f, Read1 g, Read a) => Read (Product * f g a)

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]

(Read1 f, Read1 g, Read a) => Read (Sum * f g a)

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]

(Show1 f, Show1 g, Show a) => Show (Product * f g a)

Methods

showsPrec :: Int -> Product * f g a -> ShowS

show :: Product * f g a -> String

showList :: [Product * f g a] -> ShowS

(Show1 f, Show1 g, Show a) => Show (Sum * f g a)

Methods

showsPrec :: Int -> Sum * f g a -> ShowS

show :: Sum * f g a -> String

showList :: [Sum * f g a] -> ShowS

(Applicative f, Applicative g) => Applicative (Compose * * f g)

Methods

pure :: a -> Compose * * f g a

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

(*>) :: 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 g) => Foldable (Compose * * f g)

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 g) => Traversable (Compose * * f g)

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)

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

Associated Types

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

Methods

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

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

(Alternative f, Applicative g) => Alternative (Compose * * f g)

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]

(Show1 f, Show1 g) => Show1 (Compose * * f g)

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)

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Compose * * f g a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Compose * * f g a]

(Ord1 f, Ord1 g) => Ord1 (Compose * * f g)

Methods

liftCompare :: (a -> b -> Ordering) -> Compose * * f g a -> Compose * * f g b -> Ordering

(Eq1 f, Eq1 g) => Eq1 (Compose * * f g)

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)

Methods

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

(/=) :: Compose * * f g a -> Compose * * f g a -> Bool

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

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)

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)

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 (Proxy *)

type Rep1 (Proxy *) = D1 (MetaData "Proxy" "Data.Proxy" "base" False) (C1 (MetaCons "Proxy" PrefixI False) U1)

type Rep1 (Alt * f)

type Rep1 (Alt * f) = D1 (MetaData "Alt" "Data.Monoid" "base" True) (C1 (MetaCons "Alt" PrefixI True) (S1 (MetaSel (Just Symbol "getAlt") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 f)))

type Rep1 (Const * a)

type Rep1 (Const * a) = D1 (MetaData "Const" "Data.Functor.Const" "base" True) (C1 (MetaCons "Const" PrefixI True) (S1 (MetaSel (Just Symbol "getConst") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

type Rep1 (Product * f g)

type Rep1 (Product * f g) = D1 (MetaData "Product" "Data.Functor.Product" "base" False) (C1 (MetaCons "Pair" PrefixI False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 f)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 g))))

type Rep1 (Sum * f g)

type Rep1 (Sum * f g) = D1 (MetaData "Sum" "Data.Functor.Sum" "base" False) ((:+:) (C1 (MetaCons "InL" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 f))) (C1 (MetaCons "InR" PrefixI False) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 g))))

type Rep1 (Compose * * f g)

type Rep1 (Compose * * f g) = D1 (MetaData "Compose" "Data.Functor.Compose" "base" True) (C1 (MetaCons "Compose" PrefixI True) (S1 (MetaSel (Just Symbol "getCompose") NoSourceUnpackedness NoSourceStrictness DecidedLazy) ((:.:) f (Rec1 g))))

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

PtrRepLifted

lifted; represented by a pointer

PtrRepUnlifted

unlifted; represented by a pointer

VoidRep

erased entirely

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

UnboxedTupleRep

An unboxed tuple; this doesn't specify a concrete rep

data VecCount :: *

Length of a SIMD vector type

Constructors

Vec2

Vec4

Vec8

Vec16

Vec32

Vec64

data VecElem :: *

Element of a SIMD vector type

Constructors

Int8ElemRep

Int16ElemRep

Int32ElemRep

Int64ElemRep

Word8ElemRep

Word16ElemRep

Word32ElemRep

Word64ElemRep

FloatElemRep

DoubleElemRep

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)

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 maintined 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

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]

Associated Types

type Item [a] :: *

Methods

fromList :: [Item [a]] -> [a]

fromListN :: Int -> [Item [a]] -> [a]

toList :: [a] -> [Item [a]]

IsList (NonEmpty a)

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)]