GHC.Exts

base-4.9.0.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
- Levity 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 :: TYPE Lifted = I# Int#
- data Word :: TYPE Lifted = W# Word#
- data Float :: TYPE Lifted = F# Float#
- data Double :: TYPE Lifted = D# Double#
- data Char :: TYPE Lifted = 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 (TYPE Lifted) 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 :: Levity -> TYPE Lifted
- data Levity :: TYPE Lifted
  - = Lifted
  - | Unlifted
- 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 :: TYPE Lifted
- class IsList l where
  - type Item l

# Representations of some basic types

data Int :: TYPE Lifted 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 (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c Int) Source dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) 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
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 = UInt { uInt# :: Int# } | Used for marking occurrences of `Int#`
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 :: TYPE Lifted 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 (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c Word) Source dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) 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
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 = UWord { uWord# :: Word# } | Used for marking occurrences of `Word#`
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 :: TYPE Lifted 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 (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c Float) Source dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) 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
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 = UFloat { uFloat# :: Float# } | Used for marking occurrences of `Float#`
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 :: TYPE Lifted 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 (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c Double) Source dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) 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
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 = UDouble { uDouble# :: Double# } | Used for marking occurrences of `Double#`
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 :: TYPE Lifted 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 (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c Char) Source dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) 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
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 = UChar { uChar# :: Char# } | Used for marking occurrences of `Char#`
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 (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c (Ptr a)) Source dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) 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
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
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
data URec (Ptr ()) = UAddr { uAddr# :: Addr# } | Used for marking occurrences of `Addr#`
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

(~) (TYPE Lifted) a Char => IsString [a] |
Methods fromString :: String -> [a] 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 (TYPE Lifted) 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.

# Levity polymorphism

data TYPE a :: Levity -> TYPE Lifted Source

Instances

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

data Levity :: TYPE Lifted Source

GHC divides all proper types (that is, types that can perhaps be inhabited, as distinct from type constructors or type-level data) into two worlds: lifted types and unlifted types. For example, `Int` is lifted while `Int#` is unlifted. Certain operations need to be polymorphic in this distinction. A classic example is `unsafeCoerce#`, which needs to be able to coerce between lifted and unlifted types. To achieve this, we use kind polymorphism: lifted types have kind `TYPE Lifted` and unlifted ones have kind `TYPE Unlifted`. `Levity` is the kind of `Lifted` and `Unlifted`. `*` is a synonym for `TYPE Lifted` and `#` is a synonym for `TYPE Unlifted`.

Constructors

Lifted |
Unlifted |

# 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 (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c SpecConstrAnnotation) Source dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) 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 :: TYPE Lifted 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 Version | Since: 4.8.0.0
Associated Types type Item Version :: TYPE Lifted 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] :: TYPE Lifted 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) :: TYPE Lifted Source Methods fromList :: [Item (NonEmpty a)] -> NonEmpty a Source fromListN :: Int -> [Item (NonEmpty a)] -> NonEmpty a Source toList :: NonEmpty a -> [Item (NonEmpty a)] Source