base-4.9.1.0: Basic libraries

Copyright | (c) The University of Glasgow 2002
License | see libraries/base/LICENSE
Maintainer | cvs-ghc@haskell.org
Stability | internal
Portability | non-portable (GHC Extensions)
Safe Haskell | Unsafe
Language | Haskell2010

GHC.Exts

Contents

- Representations of some basic types
- The maximum tuple size
- Primitive operations
- Fusion
- Overloaded string literals
- Debugging
- Ids with special behaviour
- Safe coercions
- Equality
- Representation polymorphism
- Transform comprehensions
- Event logging
- SpecConstr annotations
- The call stack
- The Constraint kind
- Overloaded lists

Description

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

Note: no other base module should import this module.

Synopsis

- data Int :: * = I# Int#
- data Word :: * = W# Word#
- data Float :: * = F# Float#
- data Double :: * = D# Double#
- data Char :: * = C# Char#
- data Ptr a = Ptr Addr#
- data FunPtr a = FunPtr Addr#
- maxTupleSize :: Int
- module GHC.Prim
- shiftL# :: Word# -> Int# -> Word#
- shiftRL# :: Word# -> Int# -> Word#
- iShiftL# :: Int# -> Int# -> Int#
- iShiftRA# :: Int# -> Int# -> Int#
- iShiftRL# :: Int# -> Int# -> Int#
- uncheckedShiftL64# :: Word# -> Int# -> Word#
- uncheckedShiftRL64# :: Word# -> Int# -> Word#
- uncheckedIShiftL64# :: Int# -> Int# -> Int#
- uncheckedIShiftRA64# :: Int# -> Int# -> Int#
- isTrue# :: Int# -> Bool
- build :: forall a. (forall b. (a -> b -> b) -> b -> b) -> [a]
- augment :: forall a. (forall b. (a -> b -> b) -> b -> b) -> [a] -> [a]
- class IsString a where
- breakpoint :: a -> a
- breakpointCond :: Bool -> a -> a
- lazy :: a -> a
- inline :: a -> a
- coerce :: Coercible * a b => a -> b
- class (~R#) k k a b => Coercible k a b
- class (~#) j k a b => (j ~~ k) a b
- data TYPE a :: RuntimeRep -> *
- data RuntimeRep :: *
  - = VecRep VecCount VecElem
  - | PtrRepLifted
  - | PtrRepUnlifted
  - | VoidRep
  - | IntRep
  - | WordRep
  - | Int64Rep
  - | Word64Rep
  - | AddrRep
  - | FloatRep
  - | DoubleRep
  - | UnboxedTupleRep
- data VecCount :: *
  - = Vec2
  - | Vec4
  - | Vec8
  - | Vec16
  - | Vec32
  - | Vec64
- data VecElem :: *
  - = Int8ElemRep
  - | Int16ElemRep
  - | Int32ElemRep
  - | Int64ElemRep
  - | Word8ElemRep
  - | Word16ElemRep
  - | Word32ElemRep
  - | Word64ElemRep
  - | FloatElemRep
  - | DoubleElemRep
- newtype Down a = Down a
- groupWith :: Ord b => (a -> b) -> [a] -> [[a]]
- sortWith :: Ord b => (a -> b) -> [a] -> [a]
- the :: Eq a => [a] -> a
- traceEvent :: String -> IO ()
- data SpecConstrAnnotation
  - = NoSpecConstr
  - | ForceSpecConstr
- currentCallStack :: IO [String]
- data Constraint :: *
- class IsList l where
  - type Item l

# Representations of some basic types

data Int :: * Source #

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 Source # maxBound :: Int Source #
Enum Int # |
Methods succ :: Int -> Int Source # pred :: Int -> Int Source # toEnum :: Int -> Int Source # fromEnum :: Int -> Int Source # enumFrom :: Int -> [Int] Source # enumFromThen :: Int -> Int -> [Int] Source # enumFromTo :: Int -> Int -> [Int] Source # enumFromThenTo :: Int -> Int -> Int -> [Int] Source #
Eq Int |
Methods (==) :: Int -> Int -> Bool Source # (/=) :: Int -> Int -> Bool Source #
Integral Int # |
Methods quot :: Int -> Int -> Int Source # rem :: Int -> Int -> Int Source # div :: Int -> Int -> Int Source # mod :: Int -> Int -> Int Source # quotRem :: Int -> Int -> (Int, Int) Source # divMod :: Int -> Int -> (Int, Int) Source # toInteger :: Int -> Integer Source #
Data Int # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int -> c Int Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int Source # toConstr :: Int -> Constr Source # dataTypeOf :: Int -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Int) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int) Source # gmapT :: (forall b. Data b => b -> b) -> Int -> Int Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Int -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int -> m Int Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int -> m Int Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int -> m Int Source #
Num Int # |
Methods (+) :: Int -> Int -> Int Source # (-) :: Int -> Int -> Int Source # (*) :: Int -> Int -> Int Source # negate :: Int -> Int Source # abs :: Int -> Int Source # signum :: Int -> Int Source # fromInteger :: Integer -> Int Source #
Ord Int |
Methods compare :: Int -> Int -> Ordering Source # (<) :: Int -> Int -> Bool Source # (<=) :: Int -> Int -> Bool Source # (>) :: Int -> Int -> Bool Source # (>=) :: Int -> Int -> Bool Source # max :: Int -> Int -> Int Source # min :: Int -> Int -> Int Source #
Read Int # |
Methods readsPrec :: Int -> ReadS Int Source # readList :: ReadS [Int] Source # readPrec :: ReadPrec Int Source # readListPrec :: ReadPrec [Int] Source #
Real Int # |
Methods toRational :: Int -> Rational Source #
Show Int # |
Methods showsPrec :: Int -> Int -> ShowS Source # show :: Int -> String Source # showList :: [Int] -> ShowS Source #
Ix Int # |
Methods range :: (Int, Int) -> [Int] Source # index :: (Int, Int) -> Int -> Int Source # unsafeIndex :: (Int, Int) -> Int -> Int inRange :: (Int, Int) -> Int -> Bool Source # rangeSize :: (Int, Int) -> Int Source # unsafeRangeSize :: (Int, Int) -> Int
FiniteBits Int # |
Methods finiteBitSize :: Int -> Int Source # countLeadingZeros :: Int -> Int Source # countTrailingZeros :: Int -> Int Source #
Bits Int # |
Methods (.&.) :: Int -> Int -> Int Source # (.|.) :: Int -> Int -> Int Source # xor :: Int -> Int -> Int Source # complement :: Int -> Int Source # shift :: Int -> Int -> Int Source # rotate :: Int -> Int -> Int Source # zeroBits :: Int Source # bit :: Int -> Int Source # setBit :: Int -> Int -> Int Source # clearBit :: Int -> Int -> Int Source # complementBit :: Int -> Int -> Int Source # testBit :: Int -> Int -> Bool Source # bitSizeMaybe :: Int -> Maybe Int Source # bitSize :: Int -> Int Source # isSigned :: Int -> Bool Source # shiftL :: Int -> Int -> Int Source # unsafeShiftL :: Int -> Int -> Int Source # shiftR :: Int -> Int -> Int Source # unsafeShiftR :: Int -> Int -> Int Source # rotateL :: Int -> Int -> Int Source # rotateR :: Int -> Int -> Int Source # popCount :: Int -> Int Source #
Storable Int # |
Methods sizeOf :: Int -> Int Source # alignment :: Int -> Int Source # peekElemOff :: Ptr Int -> Int -> IO Int Source # pokeElemOff :: Ptr Int -> Int -> Int -> IO () Source # peekByteOff :: Ptr b -> Int -> IO Int Source # pokeByteOff :: Ptr b -> Int -> Int -> IO () Source # peek :: Ptr Int -> IO Int Source # poke :: Ptr Int -> Int -> IO () Source #
PrintfArg Int # |
Methods formatArg :: Int -> FieldFormatter Source # parseFormat :: Int -> ModifierParser Source #
Functor (URec Int) # |
Methods fmap :: (a -> b) -> URec Int a -> URec Int b Source # (<$) :: a -> URec Int b -> URec Int a Source #
Foldable (URec Int) # |
Methods fold :: Monoid m => URec Int m -> m Source # foldMap :: Monoid m => (a -> m) -> URec Int a -> m Source # foldr :: (a -> b -> b) -> b -> URec Int a -> b Source # foldr' :: (a -> b -> b) -> b -> URec Int a -> b Source # foldl :: (b -> a -> b) -> b -> URec Int a -> b Source # foldl' :: (b -> a -> b) -> b -> URec Int a -> b Source # foldr1 :: (a -> a -> a) -> URec Int a -> a Source # foldl1 :: (a -> a -> a) -> URec Int a -> a Source # toList :: URec Int a -> [a] Source # null :: URec Int a -> Bool Source # length :: URec Int a -> Int Source # elem :: Eq a => a -> URec Int a -> Bool Source # maximum :: Ord a => URec Int a -> a Source # minimum :: Ord a => URec Int a -> a Source # sum :: Num a => URec Int a -> a Source # product :: Num a => URec Int a -> a Source #
Traversable (URec Int) # |
Methods traverse :: Applicative f => (a -> f b) -> URec Int a -> f (URec Int b) Source # sequenceA :: Applicative f => URec Int (f a) -> f (URec Int a) Source # mapM :: Monad m => (a -> m b) -> URec Int a -> m (URec Int b) Source # sequence :: Monad m => URec Int (m a) -> m (URec Int a) Source #
Generic1 (URec Int) # |
Associated Types type Rep1 (URec Int :: * -> *) :: * -> * Source # Methods from1 :: URec Int a -> Rep1 (URec Int) a Source # to1 :: Rep1 (URec Int) a -> URec Int a Source #
Eq (URec Int p) # |
Methods (==) :: URec Int p -> URec Int p -> Bool Source # (/=) :: URec Int p -> URec Int p -> Bool Source #
Ord (URec Int p) # |
Methods compare :: URec Int p -> URec Int p -> Ordering Source # (<) :: URec Int p -> URec Int p -> Bool Source # (<=) :: URec Int p -> URec Int p -> Bool Source # (>) :: URec Int p -> URec Int p -> Bool Source # (>=) :: URec Int p -> URec Int p -> Bool Source # max :: URec Int p -> URec Int p -> URec Int p Source # min :: URec Int p -> URec Int p -> URec Int p Source #
Show (URec Int p) # |
Methods showsPrec :: Int -> URec Int p -> ShowS Source # show :: URec Int p -> String Source # showList :: [URec Int p] -> ShowS Source #
Generic (URec Int p) # |
Associated Types type Rep (URec Int p) :: * -> * Source # Methods from :: URec Int p -> Rep (URec Int p) x Source # to :: Rep (URec Int p) x -> URec Int p Source #
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 :: * Source #

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

Constructors

W# Word# |

Instances

Bounded Word # |
Methods minBound :: Word Source # maxBound :: Word Source #
Enum Word # |
Methods succ :: Word -> Word Source # pred :: Word -> Word Source # toEnum :: Int -> Word Source # fromEnum :: Word -> Int Source # enumFrom :: Word -> [Word] Source # enumFromThen :: Word -> Word -> [Word] Source # enumFromTo :: Word -> Word -> [Word] Source # enumFromThenTo :: Word -> Word -> Word -> [Word] Source #
Eq Word |
Methods (==) :: Word -> Word -> Bool Source # (/=) :: Word -> Word -> Bool Source #
Integral Word # |
Methods quot :: Word -> Word -> Word Source # rem :: Word -> Word -> Word Source # div :: Word -> Word -> Word Source # mod :: Word -> Word -> Word Source # quotRem :: Word -> Word -> (Word, Word) Source # divMod :: Word -> Word -> (Word, Word) Source # toInteger :: Word -> Integer Source #
Data Word # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word -> c Word Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word Source # toConstr :: Word -> Constr Source # dataTypeOf :: Word -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Word) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word) Source # gmapT :: (forall b. Data b => b -> b) -> Word -> Word Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Word -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Word -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word -> m Word Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word -> m Word Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word -> m Word Source #
Num Word # |
Methods (+) :: Word -> Word -> Word Source # (-) :: Word -> Word -> Word Source # (*) :: Word -> Word -> Word Source # negate :: Word -> Word Source # abs :: Word -> Word Source # signum :: Word -> Word Source # fromInteger :: Integer -> Word Source #
Ord Word |
Methods compare :: Word -> Word -> Ordering Source # (<) :: Word -> Word -> Bool Source # (<=) :: Word -> Word -> Bool Source # (>) :: Word -> Word -> Bool Source # (>=) :: Word -> Word -> Bool Source # max :: Word -> Word -> Word Source # min :: Word -> Word -> Word Source #
Read Word # |
Methods readsPrec :: Int -> ReadS Word Source # readList :: ReadS [Word] Source # readPrec :: ReadPrec Word Source # readListPrec :: ReadPrec [Word] Source #
Real Word # |
Methods toRational :: Word -> Rational Source #
Show Word # |
Methods showsPrec :: Int -> Word -> ShowS Source # show :: Word -> String Source # showList :: [Word] -> ShowS Source #
Ix Word # |
Methods range :: (Word, Word) -> [Word] Source # index :: (Word, Word) -> Word -> Int Source # unsafeIndex :: (Word, Word) -> Word -> Int inRange :: (Word, Word) -> Word -> Bool Source # rangeSize :: (Word, Word) -> Int Source # unsafeRangeSize :: (Word, Word) -> Int
FiniteBits Word # |
Methods finiteBitSize :: Word -> Int Source # countLeadingZeros :: Word -> Int Source # countTrailingZeros :: Word -> Int Source #
Bits Word # |
Methods (.&.) :: Word -> Word -> Word Source # (.|.) :: Word -> Word -> Word Source # xor :: Word -> Word -> Word Source # complement :: Word -> Word Source # shift :: Word -> Int -> Word Source # rotate :: Word -> Int -> Word Source # zeroBits :: Word Source # bit :: Int -> Word Source # setBit :: Word -> Int -> Word Source # clearBit :: Word -> Int -> Word Source # complementBit :: Word -> Int -> Word Source # testBit :: Word -> Int -> Bool Source # bitSizeMaybe :: Word -> Maybe Int Source # bitSize :: Word -> Int Source # isSigned :: Word -> Bool Source # shiftL :: Word -> Int -> Word Source # unsafeShiftL :: Word -> Int -> Word Source # shiftR :: Word -> Int -> Word Source # unsafeShiftR :: Word -> Int -> Word Source # rotateL :: Word -> Int -> Word Source # rotateR :: Word -> Int -> Word Source # popCount :: Word -> Int Source #
Storable Word # |
Methods sizeOf :: Word -> Int Source # alignment :: Word -> Int Source # peekElemOff :: Ptr Word -> Int -> IO Word Source # pokeElemOff :: Ptr Word -> Int -> Word -> IO () Source # peekByteOff :: Ptr b -> Int -> IO Word Source # pokeByteOff :: Ptr b -> Int -> Word -> IO () Source # peek :: Ptr Word -> IO Word Source # poke :: Ptr Word -> Word -> IO () Source #
PrintfArg Word # |
Methods formatArg :: Word -> FieldFormatter Source # parseFormat :: Word -> ModifierParser Source #
Functor (URec Word) # |
Methods fmap :: (a -> b) -> URec Word a -> URec Word b Source # (<$) :: a -> URec Word b -> URec Word a Source #
Foldable (URec Word) # |
Methods fold :: Monoid m => URec Word m -> m Source # foldMap :: Monoid m => (a -> m) -> URec Word a -> m Source # foldr :: (a -> b -> b) -> b -> URec Word a -> b Source # foldr' :: (a -> b -> b) -> b -> URec Word a -> b Source # foldl :: (b -> a -> b) -> b -> URec Word a -> b Source # foldl' :: (b -> a -> b) -> b -> URec Word a -> b Source # foldr1 :: (a -> a -> a) -> URec Word a -> a Source # foldl1 :: (a -> a -> a) -> URec Word a -> a Source # toList :: URec Word a -> [a] Source # null :: URec Word a -> Bool Source # length :: URec Word a -> Int Source # elem :: Eq a => a -> URec Word a -> Bool Source # maximum :: Ord a => URec Word a -> a Source # minimum :: Ord a => URec Word a -> a Source # sum :: Num a => URec Word a -> a Source # product :: Num a => URec Word a -> a Source #
Traversable (URec Word) # |
Methods traverse :: Applicative f => (a -> f b) -> URec Word a -> f (URec Word b) Source # sequenceA :: Applicative f => URec Word (f a) -> f (URec Word a) Source # mapM :: Monad m => (a -> m b) -> URec Word a -> m (URec Word b) Source # sequence :: Monad m => URec Word (m a) -> m (URec Word a) Source #
Generic1 (URec Word) # |
Associated Types type Rep1 (URec Word :: * -> *) :: * -> * Source # Methods from1 :: URec Word a -> Rep1 (URec Word) a Source # to1 :: Rep1 (URec Word) a -> URec Word a Source #
Eq (URec Word p) # |
Methods (==) :: URec Word p -> URec Word p -> Bool Source # (/=) :: URec Word p -> URec Word p -> Bool Source #
Ord (URec Word p) # |
Methods compare :: URec Word p -> URec Word p -> Ordering Source # (<) :: URec Word p -> URec Word p -> Bool Source # (<=) :: URec Word p -> URec Word p -> Bool Source # (>) :: URec Word p -> URec Word p -> Bool Source # (>=) :: URec Word p -> URec Word p -> Bool Source # max :: URec Word p -> URec Word p -> URec Word p Source # min :: URec Word p -> URec Word p -> URec Word p Source #
Show (URec Word p) # |
Methods showsPrec :: Int -> URec Word p -> ShowS Source # show :: URec Word p -> String Source # showList :: [URec Word p] -> ShowS Source #
Generic (URec Word p) # |
Associated Types type Rep (URec Word p) :: * -> * Source # Methods from :: URec Word p -> Rep (URec Word p) x Source # to :: Rep (URec Word p) x -> URec Word p Source #
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 :: * Source #

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 Source # (/=) :: Float -> Float -> Bool Source #
Floating Float # |
Methods pi :: Float Source # exp :: Float -> Float Source # log :: Float -> Float Source # sqrt :: Float -> Float Source # (**) :: Float -> Float -> Float Source # logBase :: Float -> Float -> Float Source # sin :: Float -> Float Source # cos :: Float -> Float Source # tan :: Float -> Float Source # asin :: Float -> Float Source # acos :: Float -> Float Source # atan :: Float -> Float Source # sinh :: Float -> Float Source # cosh :: Float -> Float Source # tanh :: Float -> Float Source # asinh :: Float -> Float Source # acosh :: Float -> Float Source # atanh :: Float -> Float Source # log1p :: Float -> Float Source # expm1 :: Float -> Float Source # log1pexp :: Float -> Float Source # log1mexp :: Float -> Float Source #
Data Float # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Float -> c Float Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Float Source # toConstr :: Float -> Constr Source # dataTypeOf :: Float -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Float) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Float) Source # gmapT :: (forall b. Data b => b -> b) -> Float -> Float Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Float -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Float -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Float -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Float -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Float -> m Float Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Float -> m Float Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Float -> m Float Source #
Ord Float |
Methods compare :: Float -> Float -> Ordering Source # (<) :: Float -> Float -> Bool Source # (<=) :: Float -> Float -> Bool Source # (>) :: Float -> Float -> Bool Source # (>=) :: Float -> Float -> Bool Source # max :: Float -> Float -> Float Source # min :: Float -> Float -> Float Source #
Read Float # |
Methods readsPrec :: Int -> ReadS Float Source # readList :: ReadS [Float] Source # readPrec :: ReadPrec Float Source # readListPrec :: ReadPrec [Float] Source #
RealFloat Float # |
Methods floatRadix :: Float -> Integer Source # floatDigits :: Float -> Int Source # floatRange :: Float -> (Int, Int) Source # decodeFloat :: Float -> (Integer, Int) Source # encodeFloat :: Integer -> Int -> Float Source # exponent :: Float -> Int Source # significand :: Float -> Float Source # scaleFloat :: Int -> Float -> Float Source # isNaN :: Float -> Bool Source # isInfinite :: Float -> Bool Source # isDenormalized :: Float -> Bool Source # isNegativeZero :: Float -> Bool Source # isIEEE :: Float -> Bool Source # atan2 :: Float -> Float -> Float Source #
Storable Float # |
Methods sizeOf :: Float -> Int Source # alignment :: Float -> Int Source # peekElemOff :: Ptr Float -> Int -> IO Float Source # pokeElemOff :: Ptr Float -> Int -> Float -> IO () Source # peekByteOff :: Ptr b -> Int -> IO Float Source # pokeByteOff :: Ptr b -> Int -> Float -> IO () Source # peek :: Ptr Float -> IO Float Source # poke :: Ptr Float -> Float -> IO () Source #
PrintfArg Float # |
Methods formatArg :: Float -> FieldFormatter Source # parseFormat :: Float -> ModifierParser Source #
Functor (URec Float) # |
Methods fmap :: (a -> b) -> URec Float a -> URec Float b Source # (<$) :: a -> URec Float b -> URec Float a Source #
Foldable (URec Float) # |
Methods fold :: Monoid m => URec Float m -> m Source # foldMap :: Monoid m => (a -> m) -> URec Float a -> m Source # foldr :: (a -> b -> b) -> b -> URec Float a -> b Source # foldr' :: (a -> b -> b) -> b -> URec Float a -> b Source # foldl :: (b -> a -> b) -> b -> URec Float a -> b Source # foldl' :: (b -> a -> b) -> b -> URec Float a -> b Source # foldr1 :: (a -> a -> a) -> URec Float a -> a Source # foldl1 :: (a -> a -> a) -> URec Float a -> a Source # toList :: URec Float a -> [a] Source # null :: URec Float a -> Bool Source # length :: URec Float a -> Int Source # elem :: Eq a => a -> URec Float a -> Bool Source # maximum :: Ord a => URec Float a -> a Source # minimum :: Ord a => URec Float a -> a Source # sum :: Num a => URec Float a -> a Source # product :: Num a => URec Float a -> a Source #
Traversable (URec Float) # |
Methods traverse :: Applicative f => (a -> f b) -> URec Float a -> f (URec Float b) Source # sequenceA :: Applicative f => URec Float (f a) -> f (URec Float a) Source # mapM :: Monad m => (a -> m b) -> URec Float a -> m (URec Float b) Source # sequence :: Monad m => URec Float (m a) -> m (URec Float a) Source #
Generic1 (URec Float) # |
Associated Types type Rep1 (URec Float :: * -> *) :: * -> * Source # Methods from1 :: URec Float a -> Rep1 (URec Float) a Source # to1 :: Rep1 (URec Float) a -> URec Float a Source #
Eq (URec Float p) # |
Methods (==) :: URec Float p -> URec Float p -> Bool Source # (/=) :: URec Float p -> URec Float p -> Bool Source #
Ord (URec Float p) # |
Methods compare :: URec Float p -> URec Float p -> Ordering Source # (<) :: URec Float p -> URec Float p -> Bool Source # (<=) :: URec Float p -> URec Float p -> Bool Source # (>) :: URec Float p -> URec Float p -> Bool Source # (>=) :: URec Float p -> URec Float p -> Bool Source # max :: URec Float p -> URec Float p -> URec Float p Source # min :: URec Float p -> URec Float p -> URec Float p Source #
Show (URec Float p) # |
Methods showsPrec :: Int -> URec Float p -> ShowS Source # show :: URec Float p -> String Source # showList :: [URec Float p] -> ShowS Source #
Generic (URec Float p) # |
Associated Types type Rep (URec Float p) :: * -> * Source # Methods from :: URec Float p -> Rep (URec Float p) x Source # to :: Rep (URec Float p) x -> URec Float p Source #
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 :: * Source #

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 Source # (/=) :: Double -> Double -> Bool Source #
Floating Double # |
Methods pi :: Double Source # exp :: Double -> Double Source # log :: Double -> Double Source # sqrt :: Double -> Double Source # (**) :: Double -> Double -> Double Source # logBase :: Double -> Double -> Double Source # sin :: Double -> Double Source # cos :: Double -> Double Source # tan :: Double -> Double Source # asin :: Double -> Double Source # acos :: Double -> Double Source # atan :: Double -> Double Source # sinh :: Double -> Double Source # cosh :: Double -> Double Source # tanh :: Double -> Double Source # asinh :: Double -> Double Source # acosh :: Double -> Double Source # atanh :: Double -> Double Source # log1p :: Double -> Double Source # expm1 :: Double -> Double Source # log1pexp :: Double -> Double Source # log1mexp :: Double -> Double Source #
Data Double # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Double -> c Double Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Double Source # toConstr :: Double -> Constr Source # dataTypeOf :: Double -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Double) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Double) Source # gmapT :: (forall b. Data b => b -> b) -> Double -> Double Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Double -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Double -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Double -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Double -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Double -> m Double Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Double -> m Double Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Double -> m Double Source #
Ord Double |
Methods compare :: Double -> Double -> Ordering Source # (<) :: Double -> Double -> Bool Source # (<=) :: Double -> Double -> Bool Source # (>) :: Double -> Double -> Bool Source # (>=) :: Double -> Double -> Bool Source # max :: Double -> Double -> Double Source # min :: Double -> Double -> Double Source #
Read Double # |
Methods readsPrec :: Int -> ReadS Double Source # readList :: ReadS [Double] Source # readPrec :: ReadPrec Double Source # readListPrec :: ReadPrec [Double] Source #
RealFloat Double # |
Methods floatRadix :: Double -> Integer Source # floatDigits :: Double -> Int Source # floatRange :: Double -> (Int, Int) Source # decodeFloat :: Double -> (Integer, Int) Source # encodeFloat :: Integer -> Int -> Double Source # exponent :: Double -> Int Source # significand :: Double -> Double Source # scaleFloat :: Int -> Double -> Double Source # isNaN :: Double -> Bool Source # isInfinite :: Double -> Bool Source # isDenormalized :: Double -> Bool Source # isNegativeZero :: Double -> Bool Source # isIEEE :: Double -> Bool Source # atan2 :: Double -> Double -> Double Source #
Storable Double # |
Methods sizeOf :: Double -> Int Source # alignment :: Double -> Int Source # peekElemOff :: Ptr Double -> Int -> IO Double Source # pokeElemOff :: Ptr Double -> Int -> Double -> IO () Source # peekByteOff :: Ptr b -> Int -> IO Double Source # pokeByteOff :: Ptr b -> Int -> Double -> IO () Source # peek :: Ptr Double -> IO Double Source # poke :: Ptr Double -> Double -> IO () Source #
PrintfArg Double # |
Methods formatArg :: Double -> FieldFormatter Source # parseFormat :: Double -> ModifierParser Source #
Functor (URec Double) # |
Methods fmap :: (a -> b) -> URec Double a -> URec Double b Source # (<$) :: a -> URec Double b -> URec Double a Source #
Foldable (URec Double) # |
Methods fold :: Monoid m => URec Double m -> m Source # foldMap :: Monoid m => (a -> m) -> URec Double a -> m Source # foldr :: (a -> b -> b) -> b -> URec Double a -> b Source # foldr' :: (a -> b -> b) -> b -> URec Double a -> b Source # foldl :: (b -> a -> b) -> b -> URec Double a -> b Source # foldl' :: (b -> a -> b) -> b -> URec Double a -> b Source # foldr1 :: (a -> a -> a) -> URec Double a -> a Source # foldl1 :: (a -> a -> a) -> URec Double a -> a Source # toList :: URec Double a -> [a] Source # null :: URec Double a -> Bool Source # length :: URec Double a -> Int Source # elem :: Eq a => a -> URec Double a -> Bool Source # maximum :: Ord a => URec Double a -> a Source # minimum :: Ord a => URec Double a -> a Source # sum :: Num a => URec Double a -> a Source # product :: Num a => URec Double a -> a Source #
Traversable (URec Double) # |
Methods traverse :: Applicative f => (a -> f b) -> URec Double a -> f (URec Double b) Source # sequenceA :: Applicative f => URec Double (f a) -> f (URec Double a) Source # mapM :: Monad m => (a -> m b) -> URec Double a -> m (URec Double b) Source # sequence :: Monad m => URec Double (m a) -> m (URec Double a) Source #
Generic1 (URec Double) # |
Associated Types type Rep1 (URec Double :: * -> *) :: * -> * Source # Methods from1 :: URec Double a -> Rep1 (URec Double) a Source # to1 :: Rep1 (URec Double) a -> URec Double a Source #
Eq (URec Double p) # |
Methods (==) :: URec Double p -> URec Double p -> Bool Source # (/=) :: URec Double p -> URec Double p -> Bool Source #
Ord (URec Double p) # |
Methods compare :: URec Double p -> URec Double p -> Ordering Source # (<) :: URec Double p -> URec Double p -> Bool Source # (<=) :: URec Double p -> URec Double p -> Bool Source # (>) :: URec Double p -> URec Double p -> Bool Source # (>=) :: URec Double p -> URec Double p -> Bool Source # max :: URec Double p -> URec Double p -> URec Double p Source # min :: URec Double p -> URec Double p -> URec Double p Source #
Show (URec Double p) # |
Methods showsPrec :: Int -> URec Double p -> ShowS Source # show :: URec Double p -> String Source # showList :: [URec Double p] -> ShowS Source #
Generic (URec Double p) # |
Associated Types type Rep (URec Double p) :: * -> * Source # Methods from :: URec Double p -> Rep (URec Double p) x Source # to :: Rep (URec Double p) x -> URec Double p Source #
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 :: * Source #

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 Source # maxBound :: Char Source #
Enum Char # |
Methods succ :: Char -> Char Source # pred :: Char -> Char Source # toEnum :: Int -> Char Source # fromEnum :: Char -> Int Source # enumFrom :: Char -> [Char] Source # enumFromThen :: Char -> Char -> [Char] Source # enumFromTo :: Char -> Char -> [Char] Source # enumFromThenTo :: Char -> Char -> Char -> [Char] Source #
Eq Char |
Methods (==) :: Char -> Char -> Bool Source # (/=) :: Char -> Char -> Bool Source #
Data Char # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Char -> c Char Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Char Source # toConstr :: Char -> Constr Source # dataTypeOf :: Char -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Char) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Char) Source # gmapT :: (forall b. Data b => b -> b) -> Char -> Char Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Char -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Char -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Char -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Char -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Char -> m Char Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Char -> m Char Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Char -> m Char Source #
Ord Char |
Methods compare :: Char -> Char -> Ordering Source # (<) :: Char -> Char -> Bool Source # (<=) :: Char -> Char -> Bool Source # (>) :: Char -> Char -> Bool Source # (>=) :: Char -> Char -> Bool Source # max :: Char -> Char -> Char Source # min :: Char -> Char -> Char Source #
Read Char # |
Methods readsPrec :: Int -> ReadS Char Source # readList :: ReadS [Char] Source # readPrec :: ReadPrec Char Source # readListPrec :: ReadPrec [Char] Source #
Show Char # |
Methods showsPrec :: Int -> Char -> ShowS Source # show :: Char -> String Source # showList :: [Char] -> ShowS Source #
Ix Char # |
Methods range :: (Char, Char) -> [Char] Source # index :: (Char, Char) -> Char -> Int Source # unsafeIndex :: (Char, Char) -> Char -> Int inRange :: (Char, Char) -> Char -> Bool Source # rangeSize :: (Char, Char) -> Int Source # unsafeRangeSize :: (Char, Char) -> Int
Storable Char # |
Methods sizeOf :: Char -> Int Source # alignment :: Char -> Int Source # peekElemOff :: Ptr Char -> Int -> IO Char Source # pokeElemOff :: Ptr Char -> Int -> Char -> IO () Source # peekByteOff :: Ptr b -> Int -> IO Char Source # pokeByteOff :: Ptr b -> Int -> Char -> IO () Source # peek :: Ptr Char -> IO Char Source # poke :: Ptr Char -> Char -> IO () Source #
IsChar Char # |
Methods toChar :: Char -> Char Source # fromChar :: Char -> Char Source #
PrintfArg Char # |
Methods formatArg :: Char -> FieldFormatter Source # parseFormat :: Char -> ModifierParser Source #
Functor (URec Char) # |
Methods fmap :: (a -> b) -> URec Char a -> URec Char b Source # (<$) :: a -> URec Char b -> URec Char a Source #
Foldable (URec Char) # |
Methods fold :: Monoid m => URec Char m -> m Source # foldMap :: Monoid m => (a -> m) -> URec Char a -> m Source # foldr :: (a -> b -> b) -> b -> URec Char a -> b Source # foldr' :: (a -> b -> b) -> b -> URec Char a -> b Source # foldl :: (b -> a -> b) -> b -> URec Char a -> b Source # foldl' :: (b -> a -> b) -> b -> URec Char a -> b Source # foldr1 :: (a -> a -> a) -> URec Char a -> a Source # foldl1 :: (a -> a -> a) -> URec Char a -> a Source # toList :: URec Char a -> [a] Source # null :: URec Char a -> Bool Source # length :: URec Char a -> Int Source # elem :: Eq a => a -> URec Char a -> Bool Source # maximum :: Ord a => URec Char a -> a Source # minimum :: Ord a => URec Char a -> a Source # sum :: Num a => URec Char a -> a Source # product :: Num a => URec Char a -> a Source #
Traversable (URec Char) # |
Methods traverse :: Applicative f => (a -> f b) -> URec Char a -> f (URec Char b) Source # sequenceA :: Applicative f => URec Char (f a) -> f (URec Char a) Source # mapM :: Monad m => (a -> m b) -> URec Char a -> m (URec Char b) Source # sequence :: Monad m => URec Char (m a) -> m (URec Char a) Source #
Generic1 (URec Char) # |
Associated Types type Rep1 (URec Char :: * -> *) :: * -> * Source # Methods from1 :: URec Char a -> Rep1 (URec Char) a Source # to1 :: Rep1 (URec Char) a -> URec Char a Source #
Eq (URec Char p) # |
Methods (==) :: URec Char p -> URec Char p -> Bool Source # (/=) :: URec Char p -> URec Char p -> Bool Source #
Ord (URec Char p) # |
Methods compare :: URec Char p -> URec Char p -> Ordering Source # (<) :: URec Char p -> URec Char p -> Bool Source # (<=) :: URec Char p -> URec Char p -> Bool Source # (>) :: URec Char p -> URec Char p -> Bool Source # (>=) :: URec Char p -> URec Char p -> Bool Source # max :: URec Char p -> URec Char p -> URec Char p Source # min :: URec Char p -> URec Char p -> URec Char p Source #
Show (URec Char p) # |
Methods showsPrec :: Int -> URec Char p -> ShowS Source # show :: URec Char p -> String Source # showList :: [URec Char p] -> ShowS Source #
Generic (URec Char p) # |
Associated Types type Rep (URec Char p) :: * -> * Source # Methods from :: URec Char p -> Rep (URec Char p) x Source # to :: Rep (URec Char p) x -> URec Char p Source #
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 Source #

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 Source # (/=) :: Ptr a -> Ptr a -> Bool Source #
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) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Ptr a) Source # toConstr :: Ptr a -> Constr Source # dataTypeOf :: Ptr a -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Ptr a)) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Ptr a)) Source # gmapT :: (forall b. Data b => b -> b) -> Ptr a -> Ptr a Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ptr a -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ptr a -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Ptr a -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Ptr a -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ptr a -> m (Ptr a) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ptr a -> m (Ptr a) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ptr a -> m (Ptr a) Source #
Functor (URec (Ptr ())) # |
Methods fmap :: (a -> b) -> URec (Ptr ()) a -> URec (Ptr ()) b Source # (<$) :: a -> URec (Ptr ()) b -> URec (Ptr ()) a Source #
Ord (Ptr a) # |
Methods compare :: Ptr a -> Ptr a -> Ordering Source # (<) :: Ptr a -> Ptr a -> Bool Source # (<=) :: Ptr a -> Ptr a -> Bool Source # (>) :: Ptr a -> Ptr a -> Bool Source # (>=) :: Ptr a -> Ptr a -> Bool Source # max :: Ptr a -> Ptr a -> Ptr a Source # min :: Ptr a -> Ptr a -> Ptr a Source #
Show (Ptr a) # |
Methods showsPrec :: Int -> Ptr a -> ShowS Source # show :: Ptr a -> String Source # showList :: [Ptr a] -> ShowS Source #
Foldable (URec (Ptr ())) # |
Methods fold :: Monoid m => URec (Ptr ()) m -> m Source # foldMap :: Monoid m => (a -> m) -> URec (Ptr ()) a -> m Source # foldr :: (a -> b -> b) -> b -> URec (Ptr ()) a -> b Source # foldr' :: (a -> b -> b) -> b -> URec (Ptr ()) a -> b Source # foldl :: (b -> a -> b) -> b -> URec (Ptr ()) a -> b Source # foldl' :: (b -> a -> b) -> b -> URec (Ptr ()) a -> b Source # foldr1 :: (a -> a -> a) -> URec (Ptr ()) a -> a Source # foldl1 :: (a -> a -> a) -> URec (Ptr ()) a -> a Source # toList :: URec (Ptr ()) a -> [a] Source # null :: URec (Ptr ()) a -> Bool Source # length :: URec (Ptr ()) a -> Int Source # elem :: Eq a => a -> URec (Ptr ()) a -> Bool Source # maximum :: Ord a => URec (Ptr ()) a -> a Source # minimum :: Ord a => URec (Ptr ()) a -> a Source # sum :: Num a => URec (Ptr ()) a -> a Source # product :: Num a => URec (Ptr ()) a -> a Source #
Traversable (URec (Ptr ())) # |
Methods traverse :: Applicative f => (a -> f b) -> URec (Ptr ()) a -> f (URec (Ptr ()) b) Source # sequenceA :: Applicative f => URec (Ptr ()) (f a) -> f (URec (Ptr ()) a) Source # mapM :: Monad m => (a -> m b) -> URec (Ptr ()) a -> m (URec (Ptr ()) b) Source # sequence :: Monad m => URec (Ptr ()) (m a) -> m (URec (Ptr ()) a) Source #
Generic1 (URec (Ptr ())) # |
Associated Types type Rep1 (URec (Ptr ()) :: * -> *) :: * -> * Source # Methods from1 :: URec (Ptr ()) a -> Rep1 (URec (Ptr ())) a Source # to1 :: Rep1 (URec (Ptr ())) a -> URec (Ptr ()) a Source #
Storable (Ptr a) # |
Methods sizeOf :: Ptr a -> Int Source # alignment :: Ptr a -> Int Source # peekElemOff :: Ptr (Ptr a) -> Int -> IO (Ptr a) Source # pokeElemOff :: Ptr (Ptr a) -> Int -> Ptr a -> IO () Source # peekByteOff :: Ptr b -> Int -> IO (Ptr a) Source # pokeByteOff :: Ptr b -> Int -> Ptr a -> IO () Source # peek :: Ptr (Ptr a) -> IO (Ptr a) Source # poke :: Ptr (Ptr a) -> Ptr a -> IO () Source #
Eq (URec (Ptr ()) p) # |
Methods (==) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool Source # (/=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool Source #
Ord (URec (Ptr ()) p) # |
Methods compare :: URec (Ptr ()) p -> URec (Ptr ()) p -> Ordering Source # (<) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool Source # (<=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool Source # (>) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool Source # (>=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool Source # max :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p Source # min :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p Source #
Generic (URec (Ptr ()) p) # |
Associated Types type Rep (URec (Ptr ()) p) :: * -> * Source # Methods from :: URec (Ptr ()) p -> Rep (URec (Ptr ()) p) x Source # to :: Rep (URec (Ptr ()) p) x -> URec (Ptr ()) p Source #
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 Source #

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 Source # (/=) :: FunPtr a -> FunPtr a -> Bool Source #
Ord (FunPtr a) # |
Methods compare :: FunPtr a -> FunPtr a -> Ordering Source # (<) :: FunPtr a -> FunPtr a -> Bool Source # (<=) :: FunPtr a -> FunPtr a -> Bool Source # (>) :: FunPtr a -> FunPtr a -> Bool Source # (>=) :: FunPtr a -> FunPtr a -> Bool Source # max :: FunPtr a -> FunPtr a -> FunPtr a Source # min :: FunPtr a -> FunPtr a -> FunPtr a Source #
Show (FunPtr a) # |
Methods showsPrec :: Int -> FunPtr a -> ShowS Source # show :: FunPtr a -> String Source # showList :: [FunPtr a] -> ShowS Source #
Storable (FunPtr a) # |
Methods sizeOf :: FunPtr a -> Int Source # alignment :: FunPtr a -> Int Source # peekElemOff :: Ptr (FunPtr a) -> Int -> IO (FunPtr a) Source # pokeElemOff :: Ptr (FunPtr a) -> Int -> FunPtr a -> IO () Source # peekByteOff :: Ptr b -> Int -> IO (FunPtr a) Source # pokeByteOff :: Ptr b -> Int -> FunPtr a -> IO () Source # peek :: Ptr (FunPtr a) -> IO (FunPtr a) Source # poke :: Ptr (FunPtr a) -> FunPtr a -> IO () Source #

# The maximum tuple size

maxTupleSize :: Int Source #

# Primitive operations

module GHC.Prim

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

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

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

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# Source #

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

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

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# Source #

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# Source #

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

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

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

isTrue# :: Int# -> Bool Source #

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] Source #

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] Source #

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 Source #

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

Minimal complete definition

fromString

Methods

fromString :: String -> a Source #

Instances

(~) * a Char => IsString [a] # |
Methods fromString :: String -> [a] Source #
IsString a => IsString (Identity a) # |
Methods fromString :: String -> Identity a Source #
IsString a => IsString (Const * a b) # |
Methods fromString :: String -> Const * a b Source #

# Debugging

breakpoint :: a -> a Source #

breakpointCond :: Bool -> a -> a Source #

# Ids with special behaviour

lazy :: a -> a Source #

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 Source #

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 Source #

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 Source #

`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 Source #

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

Instances

Monad (Proxy *) # |
Methods (>>=) :: Proxy * a -> (a -> Proxy * b) -> Proxy * b Source # (>>) :: Proxy * a -> Proxy * b -> Proxy * b Source # return :: a -> Proxy * a Source # fail :: String -> Proxy * a Source #
Functor (Proxy *) # |
Methods fmap :: (a -> b) -> Proxy * a -> Proxy * b Source # (<$) :: a -> Proxy * b -> Proxy * a Source #
Applicative (Proxy *) # |
Methods pure :: a -> Proxy * a Source # (<*>) :: Proxy * (a -> b) -> Proxy * a -> Proxy * b Source # (*>) :: Proxy * a -> Proxy * b -> Proxy * b Source # (<*) :: Proxy * a -> Proxy * b -> Proxy * a Source #
Foldable (Proxy *) # |
Methods fold :: Monoid m => Proxy * m -> m Source # foldMap :: Monoid m => (a -> m) -> Proxy * a -> m Source # foldr :: (a -> b -> b) -> b -> Proxy * a -> b Source # foldr' :: (a -> b -> b) -> b -> Proxy * a -> b Source # foldl :: (b -> a -> b) -> b -> Proxy * a -> b Source # foldl' :: (b -> a -> b) -> b -> Proxy * a -> b Source # foldr1 :: (a -> a -> a) -> Proxy * a -> a Source # foldl1 :: (a -> a -> a) -> Proxy * a -> a Source # toList :: Proxy * a -> [a] Source # null :: Proxy * a -> Bool Source # length :: Proxy * a -> Int Source # elem :: Eq a => a -> Proxy * a -> Bool Source # maximum :: Ord a => Proxy * a -> a Source # minimum :: Ord a => Proxy * a -> a Source # sum :: Num a => Proxy * a -> a Source # product :: Num a => Proxy * a -> a Source #
Traversable (Proxy *) # |
Methods traverse :: Applicative f => (a -> f b) -> Proxy * a -> f (Proxy * b) Source # sequenceA :: Applicative f => Proxy * (f a) -> f (Proxy * a) Source # mapM :: Monad m => (a -> m b) -> Proxy * a -> m (Proxy * b) Source # sequence :: Monad m => Proxy * (m a) -> m (Proxy * a) Source #
Generic1 (Proxy *) # |
Associated Types type Rep1 (Proxy * :: * -> *) :: * -> * Source # Methods from1 :: Proxy * a -> Rep1 (Proxy *) a Source # to1 :: Rep1 (Proxy *) a -> Proxy * a Source #
MonadPlus (Proxy *) # |
Methods mzero :: Proxy * a Source # mplus :: Proxy * a -> Proxy * a -> Proxy * a Source #
Alternative (Proxy *) # |
Methods empty :: Proxy * a Source # (<|>) :: Proxy * a -> Proxy * a -> Proxy * a Source # some :: Proxy * a -> Proxy * [a] Source # many :: Proxy * a -> Proxy * [a] Source #
MonadZip (Proxy *) # |
Methods mzip :: Proxy * a -> Proxy * b -> Proxy * (a, b) Source # mzipWith :: (a -> b -> c) -> Proxy * a -> Proxy * b -> Proxy * c Source # munzip :: Proxy * (a, b) -> (Proxy * a, Proxy * b) Source #
Bifunctor (Const *) # |
Methods bimap :: (a -> b) -> (c -> d) -> Const * a c -> Const * b d Source # first :: (a -> b) -> Const * a c -> Const * b c Source # second :: (b -> c) -> Const * a b -> Const * a c Source #
Show2 (Const *) # |
Methods liftShowsPrec2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> Int -> Const * a b -> ShowS Source # liftShowList2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> [Const * a b] -> ShowS Source #
Read2 (Const *) # |
Methods liftReadsPrec2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> Int -> ReadS (Const * a b) Source # liftReadList2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> ReadS [Const * a b] Source #
Ord2 (Const *) # |
Methods liftCompare2 :: (a -> b -> Ordering) -> (c -> d -> Ordering) -> Const * a c -> Const * b d -> Ordering Source #
Eq2 (Const *) # |
Methods liftEq2 :: (a -> b -> Bool) -> (c -> d -> Bool) -> Const * a c -> Const * b d -> Bool Source #
Show1 (Proxy *) # | Since: 4.9.0.0
Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Proxy * a -> ShowS Source # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Proxy * a] -> ShowS Source #
Read1 (Proxy *) # | Since: 4.9.0.0
Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Proxy * a) Source # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Proxy * a] Source #
Ord1 (Proxy *) # | Since: 4.9.0.0
Methods liftCompare :: (a -> b -> Ordering) -> Proxy * a -> Proxy * b -> Ordering Source #
Eq1 (Proxy *) # | Since: 4.9.0.0
Methods liftEq :: (a -> b -> Bool) -> Proxy * a -> Proxy * b -> Bool Source #
Category * (->) # |
Methods id :: cat a a Source # (.) :: cat b c -> cat a b -> cat a c Source #
Monad m => Category * (Kleisli m) # |
Methods id :: cat a a Source # (.) :: cat b c -> cat a b -> cat a c Source #
Monad f => Monad (Alt * f) # |
Methods (>>=) :: Alt * f a -> (a -> Alt * f b) -> Alt * f b Source # (>>) :: Alt * f a -> Alt * f b -> Alt * f b Source # return :: a -> Alt * f a Source # fail :: String -> Alt * f a Source #
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) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Proxy * t) Source # toConstr :: Proxy * t -> Constr Source # dataTypeOf :: Proxy * t -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Proxy * t)) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Proxy * t)) Source # gmapT :: (forall b. Data b => b -> b) -> Proxy * t -> Proxy * t Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Proxy * t -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Proxy * t -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Proxy * t -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Proxy * t -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Proxy * t -> m (Proxy * t) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Proxy * t -> m (Proxy * t) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Proxy * t -> m (Proxy * t) Source #
Functor f => Functor (Alt * f) # |
Methods fmap :: (a -> b) -> Alt * f a -> Alt * f b Source # (<$) :: a -> Alt * f b -> Alt * f a Source #
Functor (Const * m) # |
Methods fmap :: (a -> b) -> Const * m a -> Const * m b Source # (<$) :: a -> Const * m b -> Const * m a Source #
MonadFix f => MonadFix (Alt * f) # |
Methods mfix :: (a -> Alt * f a) -> Alt * f a Source #
Applicative f => Applicative (Alt * f) # |
Methods pure :: a -> Alt * f a Source # (<*>) :: Alt * f (a -> b) -> Alt * f a -> Alt * f b Source # (*>) :: Alt * f a -> Alt * f b -> Alt * f b Source # (<*) :: Alt * f a -> Alt * f b -> Alt * f a Source #
Monoid m => Applicative (Const * m) # |
Methods pure :: a -> Const * m a Source # (<*>) :: Const * m (a -> b) -> Const * m a -> Const * m b Source # (*>) :: Const * m a -> Const * m b -> Const * m b Source # (<*) :: Const * m a -> Const * m b -> Const * m a Source #
Foldable (Const * m) # |
Methods fold :: Monoid m => Const * m m -> m Source # foldMap :: Monoid m => (a -> m) -> Const * m a -> m Source # foldr :: (a -> b -> b) -> b -> Const * m a -> b Source # foldr' :: (a -> b -> b) -> b -> Const * m a -> b Source # foldl :: (b -> a -> b) -> b -> Const * m a -> b Source # foldl' :: (b -> a -> b) -> b -> Const * m a -> b Source # foldr1 :: (a -> a -> a) -> Const * m a -> a Source # foldl1 :: (a -> a -> a) -> Const * m a -> a Source # toList :: Const * m a -> [a] Source # null :: Const * m a -> Bool Source # length :: Const * m a -> Int Source # elem :: Eq a => a -> Const * m a -> Bool Source # maximum :: Ord a => Const * m a -> a Source # minimum :: Ord a => Const * m a -> a Source # sum :: Num a => Const * m a -> a Source # product :: Num a => Const * m a -> a Source #
Traversable (Const * m) # |
Methods traverse :: Applicative f => (a -> f b) -> Const * m a -> f (Const * m b) Source # sequenceA :: Applicative f => Const * m (f a) -> f (Const * m a) Source # mapM :: Monad m => (a -> m b) -> Const * m a -> m (Const * m b) Source # sequence :: Monad m => Const * m (m a) -> m (Const * m a) Source #
Generic1 (Alt * f) # |
Associated Types type Rep1 (Alt * f :: * -> *) :: * -> * Source # Methods from1 :: Alt * f a -> Rep1 (Alt * f) a Source # to1 :: Rep1 (Alt * f) a -> Alt * f a Source #
Generic1 (Const * a) # |
Associated Types type Rep1 (Const * a :: * -> *) :: * -> * Source # Methods from1 :: Const * a a -> Rep1 (Const * a) a Source # to1 :: Rep1 (Const * a) a -> Const * a a Source #
MonadPlus f => MonadPlus (Alt * f) # |
Methods mzero :: Alt * f a Source # mplus :: Alt * f a -> Alt * f a -> Alt * f a Source #
Alternative f => Alternative (Alt * f) # |
Methods empty :: Alt * f a Source # (<|>) :: Alt * f a -> Alt * f a -> Alt * f a Source # some :: Alt * f a -> Alt * f [a] Source # many :: Alt * f a -> Alt * f [a] Source #
MonadZip f => MonadZip (Alt * f) # |
Methods mzip :: Alt * f a -> Alt * f b -> Alt * f (a, b) Source # mzipWith :: (a -> b -> c) -> Alt * f a -> Alt * f b -> Alt * f c Source # munzip :: Alt * f (a, b) -> (Alt * f a, Alt * f b) Source #
Show a => Show1 (Const * a) # |
Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Const * a a -> ShowS Source # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Const * a a] -> ShowS Source #
Read a => Read1 (Const * a) # |
Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Const * a a) Source # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Const * a a] Source #
Ord a => Ord1 (Const * a) # |
Methods liftCompare :: (a -> b -> Ordering) -> Const * a a -> Const * a b -> Ordering Source #
Eq a => Eq1 (Const * a) # |
Methods liftEq :: (a -> b -> Bool) -> Const * a a -> Const * a b -> Bool Source #
(Monad f, Monad g) => Monad (Product * f g) # |
Methods (>>=) :: Product * f g a -> (a -> Product * f g b) -> Product * f g b Source # (>>) :: Product * f g a -> Product * f g b -> Product * f g b Source # return :: a -> Product * f g a Source # fail :: String -> Product * f g a Source #
((~) * 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) Source # gunfold :: (forall c r. Data c => c (c -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ((* :~: a) b) Source # toConstr :: (* :~: a) b -> Constr Source # dataTypeOf :: (* :~: a) b -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ((* :~: a) b)) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ((* :~: a) b)) Source # gmapT :: (forall c. Data c => c -> c) -> (* :~: a) b -> (* :~: a) b Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (* :~: a) b -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (* :~: a) b -> r Source # gmapQ :: (forall d. Data d => d -> u) -> (* :~: a) b -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> (* :~: a) b -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> (* :~: a) b -> m ((* :~: a) b) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (* :~: a) b -> m ((* :~: a) b) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (* :~: a) b -> m ((* :~: a) b) Source #
(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) Source # gunfold :: (forall c r. Data c => c (c -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Coercion * a b) Source # toConstr :: Coercion * a b -> Constr Source # dataTypeOf :: Coercion * a b -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Coercion * a b)) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Coercion * a b)) Source # gmapT :: (forall c. Data c => c -> c) -> Coercion * a b -> Coercion * a b Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Coercion * a b -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Coercion * a b -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Coercion * a b -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Coercion * a b -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Coercion * a b -> m (Coercion * a b) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Coercion * a b -> m (Coercion * a b) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Coercion * a b -> m (Coercion * a b) Source #
(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) Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Alt * f a) Source # toConstr :: Alt * f a -> Constr Source # dataTypeOf :: Alt * f a -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Alt * f a)) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Alt * f a)) Source # gmapT :: (forall b. Data b => b -> b) -> Alt * f a -> Alt * f a Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Alt * f a -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Alt * f a -> r Source # gmapQ :: (forall d. Data d => d -> u) -> Alt * f a -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> Alt * f a -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Alt * f a -> m (Alt * f a) Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Alt * f a -> m (Alt * f a) Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Alt * f a -> m (Alt * f a) Source #
(Functor f, Functor g) => Functor (Product * f g) # |
Methods fmap :: (a -> b) -> Product * f g a -> Product * f g b Source # (<$) :: a -> Product * f g b -> Product * f g a Source #
(Functor f, Functor g) => Functor (Sum * f g) # |
Methods fmap :: (a -> b) -> Sum * f g a -> Sum * f g b Source # (<$) :: a -> Sum * f g b -> Sum * f g a Source #
(MonadFix f, MonadFix g) => MonadFix (Product * f g) # |
Methods mfix :: (a -> Product * f g a) -> Product * f g a Source #
IsString a => IsString (Const * a b) # |
Methods fromString :: String -> Const * a b Source #
(Applicative f, Applicative g) => Applicative (Product * f g) # |
Methods pure :: a -> Product * f g a Source # (<*>) :: Product * f g (a -> b) -> Product * f g a -> Product * f g b Source # (*>) :: Product * f g a -> Product * f g b -> Product * f g b Source # (<*) :: Product * f g a -> Product * f g b -> Product * f g a Source #
(Foldable f, Foldable g) => Foldable (Product * f g) # |
Methods fold :: Monoid m => Product * f g m -> m Source # foldMap :: Monoid m => (a -> m) -> Product * f g a -> m Source # foldr :: (a -> b -> b) -> b -> Product * f g a -> b Source # foldr' :: (a -> b -> b) -> b -> Product * f g a -> b Source # foldl :: (b -> a -> b) -> b -> Product * f g a -> b Source # foldl' :: (b -> a -> b) -> b -> Product * f g a -> b Source # foldr1 :: (a -> a -> a) -> Product * f g a -> a Source # foldl1 :: (a -> a -> a) -> Product * f g a -> a Source # toList :: Product * f g a -> [a] Source # null :: Product * f g a -> Bool Source # length :: Product * f g a -> Int Source # elem :: Eq a => a -> Product * f g a -> Bool Source # maximum :: Ord a => Product * f g a -> a Source # minimum :: Ord a => Product * f g a -> a Source # sum :: Num a => Product * f g a -> a Source # product :: Num a => Product * f g a -> a Source #
(Foldable f, Foldable g) => Foldable (Sum * f g) # |
Methods fold :: Monoid m => Sum * f g m -> m Source # foldMap :: Monoid m => (a -> m) -> Sum * f g a -> m Source # foldr :: (a -> b -> b) -> b -> Sum * f g a -> b Source # foldr' :: (a -> b -> b) -> b -> Sum * f g a -> b Source # foldl :: (b -> a -> b) -> b -> Sum * f g a -> b Source # foldl' :: (b -> a -> b) -> b -> Sum * f g a -> b Source # foldr1 :: (a -> a -> a) -> Sum * f g a -> a Source # foldl1 :: (a -> a -> a) -> Sum * f g a -> a Source # toList :: Sum * f g a -> [a] Source # null :: Sum * f g a -> Bool Source # length :: Sum * f g a -> Int Source # elem :: Eq a => a -> Sum * f g a -> Bool Source # maximum :: Ord a => Sum * f g a -> a Source # minimum :: Ord a => Sum * f g a -> a Source # sum :: Num a => Sum * f g a -> a Source # product :: Num a => Sum * f g a -> a Source #
(Traversable f, Traversable g) => Traversable (Product * f g) # |
Methods traverse :: Applicative f => (a -> f b) -> Product * f g a -> f (Product * f g b) Source # sequenceA :: Applicative f => Product * f g (f a) -> f (Product * f g a) Source # mapM :: Monad m => (a -> m b) -> Product * f g a -> m (Product * f g b) Source # sequence :: Monad m => Product * f g (m a) -> m (Product * f g a) Source #
(Traversable f, Traversable g) => Traversable (Sum * f g) # |
Methods traverse :: Applicative f => (a -> f b) -> Sum * f g a -> f (Sum * f g b) Source # sequenceA :: Applicative f => Sum * f g (f a) -> f (Sum * f g a) Source # mapM :: Monad m => (a -> m b) -> Sum * f g a -> m (Sum * f g b) Source # sequence :: Monad m => Sum * f g (m a) -> m (Sum * f g a) Source #
Generic1 (Product * f g) # |
Associated Types type Rep1 (Product * f g :: * -> *) :: * -> * Source # Methods from1 :: Product * f g a -> Rep1 (Product * f g) a Source # to1 :: Rep1 (Product * f g) a -> Product * f g a Source #
Generic1 (Sum * f g) # |
Associated Types type Rep1 (Sum * f g :: * -> *) :: * -> * Source # Methods from1 :: Sum * f g a -> Rep1 (Sum * f g) a Source # to1 :: Rep1 (Sum * f g) a -> Sum * f g a Source #
Alternative f => Semigroup (Alt * f a) # |
Methods (<>) :: Alt * f a -> Alt * f a -> Alt * f a Source # sconcat :: NonEmpty (Alt * f a) -> Alt * f a Source # stimes :: Integral b => b -> Alt * f a -> Alt * f a Source #
Alternative f => Monoid (Alt * f a) # |
Methods mempty :: Alt * f a Source # mappend :: Alt * f a -> Alt * f a -> Alt * f a Source # mconcat :: [Alt * f a] -> Alt * f a Source #
(MonadPlus f, MonadPlus g) => MonadPlus (Product * f g) # |
Methods mzero :: Product * f g a Source # mplus :: Product * f g a -> Product * f g a -> Product * f g a Source #
(Alternative f, Alternative g) => Alternative (Product * f g) # |
Methods empty :: Product * f g a Source # (<|>) :: Product * f g a -> Product * f g a -> Product * f g a Source # some :: Product * f g a -> Product * f g [a] Source # many :: Product * f g a -> Product * f g [a] Source #
(MonadZip f, MonadZip g) => MonadZip (Product * f g) # |
Methods mzip :: Product * f g a -> Product * f g b -> Product * f g (a, b) Source # mzipWith :: (a -> b -> c) -> Product * f g a -> Product * f g b -> Product * f g c Source # munzip :: Product * f g (a, b) -> (Product * f g a, Product * f g b) Source #
(Show1 f, Show1 g) => Show1 (Product * f g) # |
Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Product * f g a -> ShowS Source # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Product * f g a] -> ShowS Source #
(Show1 f, Show1 g) => Show1 (Sum * f g) # |
Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Sum * f g a -> ShowS Source # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Sum * f g a] -> ShowS Source #
(Read1 f, Read1 g) => Read1 (Product * f g) # |
Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Product * f g a) Source # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Product * f g a] Source #
(Read1 f, Read1 g) => Read1 (Sum * f g) # |
Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Sum * f g a) Source # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Sum * f g a] Source #
(Ord1 f, Ord1 g) => Ord1 (Product * f g) # |
Methods liftCompare :: (a -> b -> Ordering) -> Product * f g a -> Product * f g b -> Ordering Source #
(Ord1 f, Ord1 g) => Ord1 (Sum * f g) # |
Methods liftCompare :: (a -> b -> Ordering) -> Sum * f g a -> Sum * f g b -> Ordering Source #
(Eq1 f, Eq1 g) => Eq1 (Product * f g) # |
Methods liftEq :: (a -> b -> Bool) -> Product * f g a -> Product * f g b -> Bool Source #
(Eq1 f, Eq1 g) => Eq1 (Sum * f g) # |
Methods liftEq :: (a -> b -> Bool) -> Sum * f g a -> Sum * f g b -> Bool Source #
(Eq1 f, Eq1 g, Eq a) => Eq (Product * f g a) # |
Methods (==) :: Product * f g a -> Product * f g a -> Bool Source # (/=) :: Product * f g a -> Product * f g a -> Bool Source #
(Eq1 f, Eq1 g, Eq a) => Eq (Sum * f g a) # |
Methods (==) :: Sum * f g a -> Sum * f g a -> Bool Source # (/=) :: Sum * f g a -> Sum * f g a -> Bool Source #
(Functor f, Functor g) => Functor (Compose * * f g) # |
Methods fmap :: (a -> b) -> Compose * * f g a -> Compose * * f g b Source # (<$) :: a -> Compose * * f g b -> Compose * * f g a Source #
(Ord1 f, Ord1 g, Ord a) => Ord (Product * f g a) # |
Methods compare :: Product * f g a -> Product * f g a -> Ordering Source # (<) :: Product * f g a -> Product * f g a -> Bool Source # (<=) :: Product * f g a -> Product * f g a -> Bool Source # (>) :: Product * f g a -> Product * f g a -> Bool Source # (>=) :: Product * f g a -> Product * f g a -> Bool Source # max :: Product * f g a -> Product * f g a -> Product * f g a Source # min :: Product * f g a -> Product * f g a -> Product * f g a Source #
(Ord1 f, Ord1 g, Ord a) => Ord (Sum * f g a) # |
Methods compare :: Sum * f g a -> Sum * f g a -> Ordering Source # (<) :: Sum * f g a -> Sum * f g a -> Bool Source # (<=) :: Sum * f g a -> Sum * f g a -> Bool Source # (>) :: Sum * f g a -> Sum * f g a -> Bool Source # (>=) :: Sum * f g a -> Sum * f g a -> Bool Source # max :: Sum * f g a -> Sum * f g a -> Sum * f g a Source # min :: Sum * f g a -> Sum * f g a -> Sum * f g a Source #
(Read1 f, Read1 g, Read a) => Read (Product * f g a) # |
Methods readsPrec :: Int -> ReadS (Product * f g a) Source # readList :: ReadS [Product * f g a] Source # readPrec :: ReadPrec (Product * f g a) Source # readListPrec :: ReadPrec [Product * f g a] Source #
(Read1 f, Read1 g, Read a) => Read (Sum * f g a) # |
Methods readsPrec :: Int -> ReadS (Sum * f g a) Source # readList :: ReadS [Sum * f g a] Source # readPrec :: ReadPrec (Sum * f g a) Source # readListPrec :: ReadPrec [Sum * f g a] Source #
(Show1 f, Show1 g, Show a) => Show (Product * f g a) # |
Methods showsPrec :: Int -> Product * f g a -> ShowS Source # show :: Product * f g a -> String Source # showList :: [Product * f g a] -> ShowS Source #
(Show1 f, Show1 g, Show a) => Show (Sum * f g a) # |
Methods showsPrec :: Int -> Sum * f g a -> ShowS Source # show :: Sum * f g a -> String Source # showList :: [Sum * f g a] -> ShowS Source #
(Applicative f, Applicative g) => Applicative (Compose * * f g) # |
Methods pure :: a -> Compose * * f g a Source # (<*>) :: Compose * * f g (a -> b) -> Compose * * f g a -> Compose * * f g b Source # (*>) :: Compose * * f g a -> Compose * * f g b -> Compose * * f g b Source # (<*) :: Compose * * f g a -> Compose * * f g b -> Compose * * f g a Source #
(Foldable f, Foldable g) => Foldable (Compose * * f g) # |
Methods fold :: Monoid m => Compose * * f g m -> m Source # foldMap :: Monoid m => (a -> m) -> Compose * * f g a -> m Source # foldr :: (a -> b -> b) -> b -> Compose * * f g a -> b Source # foldr' :: (a -> b -> b) -> b -> Compose * * f g a -> b Source # foldl :: (b -> a -> b) -> b -> Compose * * f g a -> b Source # foldl' :: (b -> a -> b) -> b -> Compose * * f g a -> b Source # foldr1 :: (a -> a -> a) -> Compose * * f g a -> a Source # foldl1 :: (a -> a -> a) -> Compose * * f g a -> a Source # toList :: Compose * * f g a -> [a] Source # null :: Compose * * f g a -> Bool Source # length :: Compose * * f g a -> Int Source # elem :: Eq a => a -> Compose * * f g a -> Bool Source # maximum :: Ord a => Compose * * f g a -> a Source # minimum :: Ord a => Compose * * f g a -> a Source # sum :: Num a => Compose * * f g a -> a Source # product :: Num a => Compose * * f g a -> a Source #
(Traversable f, Traversable g) => Traversable (Compose * * f g) # |
Methods traverse :: Applicative f => (a -> f b) -> Compose * * f g a -> f (Compose * * f g b) Source # sequenceA :: Applicative f => Compose * * f g (f a) -> f (Compose * * f g a) Source # mapM :: Monad m => (a -> m b) -> Compose * * f g a -> m (Compose * * f g b) Source # sequence :: Monad m => Compose * * f g (m a) -> m (Compose * * f g a) Source #
Functor f => Generic1 (Compose * * f g) # |
Associated Types type Rep1 (Compose * * f g :: * -> *) :: * -> * Source # Methods from1 :: Compose * * f g a -> Rep1 (Compose * * f g) a Source # to1 :: Rep1 (Compose * * f g) a -> Compose * * f g a Source #
(Alternative f, Applicative g) => Alternative (Compose * * f g) # |
Methods empty :: Compose * * f g a Source # (<|>) :: Compose * * f g a -> Compose * * f g a -> Compose * * f g a Source # some :: Compose * * f g a -> Compose * * f g [a] Source # many :: Compose * * f g a -> Compose * * f g [a] Source #
(Show1 f, Show1 g) => Show1 (Compose * * f g) # |
Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Compose * * f g a -> ShowS Source # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Compose * * f g a] -> ShowS Source #
(Read1 f, Read1 g) => Read1 (Compose * * f g) # |
Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Compose * * f g a) Source # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Compose * * f g a] Source #
(Ord1 f, Ord1 g) => Ord1 (Compose * * f g) # |
Methods liftCompare :: (a -> b -> Ordering) -> Compose * * f g a -> Compose * * f g b -> Ordering Source #
(Eq1 f, Eq1 g) => Eq1 (Compose * * f g) # |
Methods liftEq :: (a -> b -> Bool) -> Compose * * f g a -> Compose * * f g b -> Bool Source #
(Eq1 f, Eq1 g, Eq a) => Eq (Compose * * f g a) # |
Methods (==) :: Compose * * f g a -> Compose * * f g a -> Bool Source # (/=) :: Compose * * f g a -> Compose * * f g a -> Bool Source #
(Ord1 f, Ord1 g, Ord a) => Ord (Compose * * f g a) # |
Methods compare :: Compose * * f g a -> Compose * * f g a -> Ordering Source # (<) :: Compose * * f g a -> Compose * * f g a -> Bool Source # (<=) :: Compose * * f g a -> Compose * * f g a -> Bool Source # (>) :: Compose * * f g a -> Compose * * f g a -> Bool Source # (>=) :: Compose * * f g a -> Compose * * f g a -> Bool Source # max :: Compose * * f g a -> Compose * * f g a -> Compose * * f g a Source # min :: Compose * * f g a -> Compose * * f g a -> Compose * * f g a Source #
(Read1 f, Read1 g, Read a) => Read (Compose * * f g a) # |
Methods readsPrec :: Int -> ReadS (Compose * * f g a) Source # readList :: ReadS [Compose * * f g a] Source # readPrec :: ReadPrec (Compose * * f g a) Source # readListPrec :: ReadPrec [Compose * * f g a] Source #
(Show1 f, Show1 g, Show a) => Show (Compose * * f g a) # |
Methods showsPrec :: Int -> Compose * * f g a -> ShowS Source # show :: Compose * * f g a -> String Source # showList :: [Compose * * f g a] -> ShowS Source #
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 :: * Source #

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 :: * Source #

Length of a SIMD vector type

Constructors

Vec2 |
Vec4 |
Vec8 |
Vec16 |
Vec32 |
Vec64 |

data VecElem :: * Source #

Element of a SIMD vector type

Constructors

Int8ElemRep |
Int16ElemRep |
Int32ElemRep |
Int64ElemRep |
Word8ElemRep |
Word16ElemRep |
Word32ElemRep |
Word64ElemRep |
FloatElemRep |
DoubleElemRep |

# Transform comprehensions

newtype Down a Source #

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 Source # (/=) :: Down a -> Down a -> Bool Source #
Ord a => Ord (Down a) # |
Methods compare :: Down a -> Down a -> Ordering Source # (<) :: Down a -> Down a -> Bool Source # (<=) :: Down a -> Down a -> Bool Source # (>) :: Down a -> Down a -> Bool Source # (>=) :: Down a -> Down a -> Bool Source # max :: Down a -> Down a -> Down a Source # min :: Down a -> Down a -> Down a Source #
Read a => Read (Down a) # |
Methods readsPrec :: Int -> ReadS (Down a) Source # readList :: ReadS [Down a] Source # readPrec :: ReadPrec (Down a) Source # readListPrec :: ReadPrec [Down a] Source #
Show a => Show (Down a) # |
Methods showsPrec :: Int -> Down a -> ShowS Source # show :: Down a -> String Source # showList :: [Down a] -> ShowS Source #

groupWith :: Ord b => (a -> b) -> [a] -> [[a]] Source #

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] Source #

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 Source #

`the` ensures that all the elements of the list are identical and then returns that unique element

# Event logging

traceEvent :: String -> IO () Source #

Deprecated: Use `traceEvent` or `traceEventIO`

# SpecConstr annotations

data SpecConstrAnnotation Source #

Constructors

NoSpecConstr |
ForceSpecConstr |

Instances

Eq SpecConstrAnnotation # |
Methods (==) :: SpecConstrAnnotation -> SpecConstrAnnotation -> Bool Source # (/=) :: SpecConstrAnnotation -> SpecConstrAnnotation -> Bool Source #
Data SpecConstrAnnotation # |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SpecConstrAnnotation -> c SpecConstrAnnotation Source # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SpecConstrAnnotation Source # toConstr :: SpecConstrAnnotation -> Constr Source # dataTypeOf :: SpecConstrAnnotation -> DataType Source # dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c SpecConstrAnnotation) Source # dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SpecConstrAnnotation) Source # gmapT :: (forall b. Data b => b -> b) -> SpecConstrAnnotation -> SpecConstrAnnotation Source # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SpecConstrAnnotation -> r Source # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SpecConstrAnnotation -> r Source # gmapQ :: (forall d. Data d => d -> u) -> SpecConstrAnnotation -> [u] Source # gmapQi :: Int -> (forall d. Data d => d -> u) -> SpecConstrAnnotation -> u Source # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SpecConstrAnnotation -> m SpecConstrAnnotation Source # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SpecConstrAnnotation -> m SpecConstrAnnotation Source # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SpecConstrAnnotation -> m SpecConstrAnnotation Source #

# The call stack

currentCallStack :: IO [String] Source #

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 :: * Source #

The kind of constraints, like `Show a`

# Overloaded lists

class IsList l where Source #

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 Source #

The `Item` type function returns the type of items of the structure `l`.

Methods

fromList :: [Item l] -> l Source #

The `fromList` function constructs the structure `l` from the given list of `Item l`

fromListN :: Int -> [Item l] -> l Source #

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] Source #

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 `CallStack`s, since `toList` removes frozenness information. Since: 4.9.0.0
Associated Types type Item CallStack :: * Source # Methods fromList :: [Item CallStack] -> CallStack Source # fromListN :: Int -> [Item CallStack] -> CallStack Source # toList :: CallStack -> [Item CallStack] Source #
IsList Version # | Since: 4.8.0.0
Associated Types type Item Version :: * Source # Methods fromList :: [Item Version] -> Version Source # fromListN :: Int -> [Item Version] -> Version Source # toList :: Version -> [Item Version] Source #
IsList [a] # |
Associated Types type Item [a] :: * Source # Methods fromList :: [Item [a]] -> [a] Source # fromListN :: Int -> [Item [a]] -> [a] Source # toList :: [a] -> [Item [a]] Source #
IsList (NonEmpty a) # |
Associated Types type Item (NonEmpty a) :: * Source # Methods fromList :: [Item (NonEmpty a)] -> NonEmpty a Source # fromListN :: Int -> [Item (NonEmpty a)] -> NonEmpty a Source # toList :: NonEmpty a -> [Item (NonEmpty a)] Source #