base-4.9.0.0: Basic libraries

Copyright(c) The University of Glasgow 2002
Licensesee libraries/base/LICENSE
Maintainercvs-ghc@haskell.org
Stabilityinternal
Portabilitynon-portable (GHC Extensions)
Safe HaskellUnsafe
LanguageHaskell2010

GHC.Exts

Contents

Description

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

Note: no other base module should import this module.

Synopsis

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

maxBound :: Int

Enum Int 

Methods

succ :: Int -> Int

pred :: Int -> Int

toEnum :: Int -> Int

fromEnum :: Int -> Int

enumFrom :: Int -> [Int]

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

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

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

Eq Int 

Methods

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

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

Integral Int 

Methods

quot :: Int -> Int -> Int

rem :: Int -> Int -> Int

div :: Int -> Int -> Int

mod :: Int -> Int -> Int

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

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

toInteger :: Int -> Integer

Data Int 

Methods

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

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

toConstr :: Int -> Constr

dataTypeOf :: Int -> DataType

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

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

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

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

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

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

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

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

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

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

Num Int 

Methods

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

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

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

negate :: Int -> Int

abs :: Int -> Int

signum :: Int -> Int

fromInteger :: Integer -> Int

Ord Int 

Methods

compare :: Int -> Int -> Ordering 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 
Real Int 

Methods

toRational :: Int -> Rational

Show Int 

Methods

showsPrec :: Int -> Int -> ShowS

show :: Int -> String

showList :: [Int] -> ShowS

Ix Int 

Methods

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

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

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

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

rangeSize :: (Int, Int) -> Int

unsafeRangeSize :: (Int, Int) -> Int

FiniteBits Int 
Bits Int 

Methods

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

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

xor :: Int -> Int -> Int

complement :: Int -> Int

shift :: Int -> Int -> Int

rotate :: Int -> Int -> Int

zeroBits :: Int

bit :: Int -> Int

setBit :: Int -> Int -> Int

clearBit :: Int -> Int -> Int

complementBit :: Int -> Int -> Int

testBit :: Int -> Int -> Bool

bitSizeMaybe :: Int -> Maybe Int

bitSize :: Int -> Int

isSigned :: Int -> Bool

shiftL :: Int -> Int -> Int

unsafeShiftL :: Int -> Int -> Int

shiftR :: Int -> Int -> Int

unsafeShiftR :: Int -> Int -> Int

rotateL :: Int -> Int -> Int

rotateR :: Int -> Int -> Int

popCount :: Int -> Int

Storable Int 

Methods

sizeOf :: Int -> Int

alignment :: Int -> Int

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

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

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

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

peek :: Ptr Int -> IO Int

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

PrintfArg Int 
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

show :: URec Int _p -> String

showList :: [URec Int _p] -> ShowS

Generic (URec Int _p) 

Associated Types

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

Methods

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

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

data URec Int = UInt {}

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 
Enum Word 
Eq Word 

Methods

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

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

Integral Word 

Methods

quot :: Word -> Word -> Word

rem :: Word -> Word -> Word

div :: Word -> Word -> Word

mod :: Word -> Word -> Word

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

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

toInteger :: Word -> Integer

Data Word 

Methods

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

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

toConstr :: Word -> Constr

dataTypeOf :: Word -> DataType

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

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

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

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

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

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

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

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

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

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

Num Word 

Methods

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

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

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

negate :: Word -> Word

abs :: Word -> Word

signum :: Word -> Word

fromInteger :: Integer -> Word

Ord Word 
Read Word 
Real Word 

Methods

toRational :: Word -> Rational

Show Word 

Methods

showsPrec :: Int -> Word -> ShowS

show :: Word -> String

showList :: [Word] -> ShowS

Ix Word 

Methods

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

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

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

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

rangeSize :: (Word, Word) -> Int

unsafeRangeSize :: (Word, Word) -> Int

FiniteBits Word 
Bits Word 
Storable Word 

Methods

sizeOf :: Word -> Int

alignment :: Word -> Int

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

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

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

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

peek :: Ptr Word -> IO Word

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

PrintfArg Word 
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

show :: URec Word _p -> String

showList :: [URec Word _p] -> ShowS

Generic (URec Word _p) 

Associated Types

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

Methods

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

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

data URec Word = UWord {}

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 
Data Float 

Methods

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

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

toConstr :: Float -> Constr

dataTypeOf :: Float -> DataType

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

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

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

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

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

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

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

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

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

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

Ord Float 
Read Float 
RealFloat Float 
Storable Float 

Methods

sizeOf :: Float -> Int

alignment :: Float -> Int

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

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

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

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

peek :: Ptr Float -> IO Float

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

PrintfArg Float 
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

show :: URec Float _p -> String

showList :: [URec Float _p] -> ShowS

Generic (URec Float _p) 

Associated Types

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

Methods

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

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

data URec Float = UFloat {}

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 
Floating Double 
Data Double 

Methods

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

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

toConstr :: Double -> Constr

dataTypeOf :: Double -> DataType

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

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

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

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

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

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

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

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

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

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

Ord Double 
Read Double 
RealFloat Double 
Storable Double 
PrintfArg Double 
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) 
Show (URec Double _p) 

Methods

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

show :: URec Double _p -> String

showList :: [URec Double _p] -> ShowS

Generic (URec Double _p) 

Associated Types

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

Methods

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

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

data URec Double = UDouble {}

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 
Enum Char 
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

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

toConstr :: Char -> Constr

dataTypeOf :: Char -> DataType

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

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

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

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

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

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

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

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

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

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

Ord Char 
Read Char 
Show Char 

Methods

showsPrec :: Int -> Char -> ShowS

show :: Char -> String

showList :: [Char] -> ShowS

Ix Char 

Methods

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

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

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

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

rangeSize :: (Char, Char) -> Int

unsafeRangeSize :: (Char, Char) -> Int

Storable Char 

Methods

sizeOf :: Char -> Int

alignment :: Char -> Int

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

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

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

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

peek :: Ptr Char -> IO Char

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

IsChar Char 

Methods

toChar :: Char -> Char

fromChar :: Char -> Char

PrintfArg Char 
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

show :: URec Char _p -> String

showList :: [URec Char _p] -> ShowS

Generic (URec Char _p) 

Associated Types

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

Methods

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

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

data URec Char = UChar {}

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

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)

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

toConstr :: Ptr a -> Constr

dataTypeOf :: Ptr a -> DataType

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

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

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

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

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

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

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

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

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

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

Ord (Ptr a) 

Methods

compare :: Ptr a -> Ptr a -> Ordering 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

show :: Ptr a -> String

showList :: [Ptr a] -> ShowS

Storable (Ptr a) 

Methods

sizeOf :: Ptr a -> Int

alignment :: Ptr a -> Int

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

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

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

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

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

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

Eq (URec (Ptr ()) _p) 

Methods

(==) :: URec (Ptr ()) _p -> URec (Ptr ()) _p -> Bool 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) :: * -> *

Methods

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

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

data URec (Ptr ()) = UAddr {}

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

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

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

show :: FunPtr a -> String

showList :: [FunPtr a] -> ShowS

Storable (FunPtr a) 

Methods

sizeOf :: FunPtr a -> Int

alignment :: FunPtr a -> Int

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

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

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

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

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

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

The maximum tuple size

Primitive operations

module GHC.Prim

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

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

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

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

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

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

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

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

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

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

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]

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

   build g = g (:) []

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

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

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

   augment g xs = g (:) xs

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

Overloaded string literals

class IsString a where

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

Minimal complete definition

fromString

Methods

fromString :: String -> a

Instances

(~) (TYPE Lifted) a Char => IsString [a] 

Methods

fromString :: String -> [a]

Debugging

breakpoint :: a -> a

breakpointCond :: Bool -> a -> a

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

(>>) :: Proxy (TYPE Lifted) a -> Proxy (TYPE Lifted) b -> Proxy (TYPE Lifted) b

return :: a -> Proxy (TYPE Lifted) a

fail :: String -> Proxy (TYPE Lifted) a

Functor (Proxy (TYPE Lifted)) 

Methods

fmap :: (a -> b) -> Proxy (TYPE Lifted) a -> Proxy (TYPE Lifted) b

(<$) :: a -> Proxy (TYPE Lifted) b -> Proxy (TYPE Lifted) a

Applicative (Proxy (TYPE Lifted)) 

Methods

pure :: a -> Proxy (TYPE Lifted) a

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

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

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

Foldable (Proxy (TYPE Lifted)) 

Methods

fold :: Monoid m => Proxy (TYPE Lifted) m -> m

foldMap :: Monoid m => (a -> m) -> Proxy (TYPE Lifted) a -> m

foldr :: (a -> b -> b) -> b -> Proxy (TYPE Lifted) a -> b

foldr' :: (a -> b -> b) -> b -> Proxy (TYPE Lifted) a -> b

foldl :: (b -> a -> b) -> b -> Proxy (TYPE Lifted) a -> b

foldl' :: (b -> a -> b) -> b -> Proxy (TYPE Lifted) a -> b

foldr1 :: (a -> a -> a) -> Proxy (TYPE Lifted) a -> a

foldl1 :: (a -> a -> a) -> Proxy (TYPE Lifted) a -> a

toList :: Proxy (TYPE Lifted) a -> [a]

null :: Proxy (TYPE Lifted) a -> Bool

length :: Proxy (TYPE Lifted) a -> Int

elem :: Eq a => a -> Proxy (TYPE Lifted) a -> Bool

maximum :: Ord a => Proxy (TYPE Lifted) a -> a

minimum :: Ord a => Proxy (TYPE Lifted) a -> a

sum :: Num a => Proxy (TYPE Lifted) a -> a

product :: Num a => Proxy (TYPE Lifted) a -> a

Traversable (Proxy (TYPE Lifted)) 

Methods

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

sequenceA :: Applicative f => Proxy (TYPE Lifted) (f a) -> f (Proxy (TYPE Lifted) a)

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

sequence :: Monad m => Proxy (TYPE Lifted) (m a) -> m (Proxy (TYPE Lifted) a)

Generic1 (Proxy *) 

Associated Types

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

Methods

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

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

Bifunctor (Const (TYPE Lifted)) 

Methods

bimap :: (a -> b) -> (c -> d) -> Const (TYPE Lifted) a c -> Const (TYPE Lifted) b d

first :: (a -> b) -> Const (TYPE Lifted) a c -> Const (TYPE Lifted) b c

second :: (b -> c) -> Const (TYPE Lifted) a b -> Const (TYPE Lifted) a c

Show2 (Const (TYPE Lifted)) 

Methods

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

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

Read2 (Const (TYPE Lifted)) 

Methods

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

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

Ord2 (Const (TYPE Lifted)) 

Methods

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

Eq2 (Const (TYPE Lifted)) 

Methods

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

Category (TYPE Lifted) (->) 

Methods

id :: cat a a

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

Monad m => Category (TYPE Lifted) (Kleisli m) 

Methods

id :: cat a a

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

Monad f => Monad (Alt (TYPE Lifted) f) 

Methods

(>>=) :: Alt (TYPE Lifted) f a -> (a -> Alt (TYPE Lifted) f b) -> Alt (TYPE Lifted) f b

(>>) :: Alt (TYPE Lifted) f a -> Alt (TYPE Lifted) f b -> Alt (TYPE Lifted) f b

return :: a -> Alt (TYPE Lifted) f a

fail :: String -> Alt (TYPE Lifted) f a

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)

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

toConstr :: Proxy (TYPE Lifted) t -> Constr

dataTypeOf :: Proxy (TYPE Lifted) t -> DataType

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

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

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

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

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

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

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

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

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

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

Functor f => Functor (Alt (TYPE Lifted) f) 

Methods

fmap :: (a -> b) -> Alt (TYPE Lifted) f a -> Alt (TYPE Lifted) f b

(<$) :: a -> Alt (TYPE Lifted) f b -> Alt (TYPE Lifted) f a

Functor (Const (TYPE Lifted) m) 

Methods

fmap :: (a -> b) -> Const (TYPE Lifted) m a -> Const (TYPE Lifted) m b

(<$) :: a -> Const (TYPE Lifted) m b -> Const (TYPE Lifted) m a

MonadFix f => MonadFix (Alt (TYPE Lifted) f) 

Methods

mfix :: (a -> Alt (TYPE Lifted) f a) -> Alt (TYPE Lifted) f a

Applicative f => Applicative (Alt (TYPE Lifted) f) 

Methods

pure :: a -> Alt (TYPE Lifted) f a

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

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

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

Monoid m => Applicative (Const (TYPE Lifted) m) 

Methods

pure :: a -> Const (TYPE Lifted) m a

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

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

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

Foldable (Const (TYPE Lifted) m) 

Methods

fold :: Monoid m => Const (TYPE Lifted) m m -> m

foldMap :: Monoid m => (a -> m) -> Const (TYPE Lifted) m a -> m

foldr :: (a -> b -> b) -> b -> Const (TYPE Lifted) m a -> b

foldr' :: (a -> b -> b) -> b -> Const (TYPE Lifted) m a -> b

foldl :: (b -> a -> b) -> b -> Const (TYPE Lifted) m a -> b

foldl' :: (b -> a -> b) -> b -> Const (TYPE Lifted) m a -> b

foldr1 :: (a -> a -> a) -> Const (TYPE Lifted) m a -> a

foldl1 :: (a -> a -> a) -> Const (TYPE Lifted) m a -> a

toList :: Const (TYPE Lifted) m a -> [a]

null :: Const (TYPE Lifted) m a -> Bool

length :: Const (TYPE Lifted) m a -> Int

elem :: Eq a => a -> Const (TYPE Lifted) m a -> Bool

maximum :: Ord a => Const (TYPE Lifted) m a -> a

minimum :: Ord a => Const (TYPE Lifted) m a -> a

sum :: Num a => Const (TYPE Lifted) m a -> a

product :: Num a => Const (TYPE Lifted) m a -> a

Traversable (Const (TYPE Lifted) m) 

Methods

traverse :: Applicative f => (a -> f b) -> Const (TYPE Lifted) m a -> f (Const (TYPE Lifted) m b)

sequenceA :: Applicative f => Const (TYPE Lifted) m (f a) -> f (Const (TYPE Lifted) m a)

mapM :: Monad m => (a -> m b) -> Const (TYPE Lifted) m a -> m (Const (TYPE Lifted) m b)

sequence :: Monad m => Const (TYPE Lifted) m (m a) -> m (Const (TYPE Lifted) m a)

Generic1 (Alt (TYPE Lifted) f) 

Associated Types

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

Methods

from1 :: Alt (TYPE Lifted) f a -> Rep1 (Alt (TYPE Lifted) f) a

to1 :: Rep1 (Alt (TYPE Lifted) f) a -> Alt (TYPE Lifted) f a

Generic1 (Const (TYPE Lifted) a) 

Associated Types

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

Methods

from1 :: Const (TYPE Lifted) a a -> Rep1 (Const (TYPE Lifted) a) a

to1 :: Rep1 (Const (TYPE Lifted) a) a -> Const (TYPE Lifted) a a

MonadPlus f => MonadPlus (Alt (TYPE Lifted) f) 

Methods

mzero :: Alt (TYPE Lifted) f a

mplus :: Alt (TYPE Lifted) f a -> Alt (TYPE Lifted) f a -> Alt (TYPE Lifted) f a

Alternative f => Alternative (Alt (TYPE Lifted) f) 

Methods

empty :: Alt (TYPE Lifted) f a

(<|>) :: Alt (TYPE Lifted) f a -> Alt (TYPE Lifted) f a -> Alt (TYPE Lifted) f a

some :: Alt (TYPE Lifted) f a -> Alt (TYPE Lifted) f [a]

many :: Alt (TYPE Lifted) f a -> Alt (TYPE Lifted) f [a]

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)

mzipWith :: (a -> b -> c) -> Alt (TYPE Lifted) f a -> Alt (TYPE Lifted) f b -> Alt (TYPE Lifted) f c

munzip :: Alt (TYPE Lifted) f (a, b) -> (Alt (TYPE Lifted) f a, Alt (TYPE Lifted) f b)

Show a => Show1 (Const (TYPE Lifted) a) 

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Const (TYPE Lifted) a a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Const (TYPE Lifted) a a] -> ShowS

Read a => Read1 (Const (TYPE Lifted) a) 

Methods

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

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

Ord a => Ord1 (Const (TYPE Lifted) a) 

Methods

liftCompare :: (a -> b -> Ordering) -> Const (TYPE Lifted) a a -> Const (TYPE Lifted) a b -> Ordering

Eq a => Eq1 (Const (TYPE Lifted) a) 

Methods

liftEq :: (a -> b -> Bool) -> Const (TYPE Lifted) a a -> Const (TYPE Lifted) a b -> Bool

(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

(>>) :: Product (TYPE Lifted) f g a -> Product (TYPE Lifted) f g b -> Product (TYPE Lifted) f g b

return :: a -> Product (TYPE Lifted) f g a

fail :: String -> Product (TYPE Lifted) f g a

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

gunfold :: (forall c r. Data c => c (c -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ((TYPE Lifted :~: a) b)

toConstr :: (TYPE Lifted :~: a) b -> Constr

dataTypeOf :: (TYPE Lifted :~: a) b -> DataType

dataCast1 :: Typeable (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c ((TYPE Lifted :~: a) b))

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

gmapT :: (forall c. Data c => c -> c) -> (TYPE Lifted :~: a) b -> (TYPE Lifted :~: a) b

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (TYPE Lifted :~: a) b -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (TYPE Lifted :~: a) b -> r

gmapQ :: (forall d. Data d => d -> u) -> (TYPE Lifted :~: a) b -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> (TYPE Lifted :~: a) b -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> (TYPE Lifted :~: a) b -> m ((TYPE Lifted :~: a) b)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (TYPE Lifted :~: a) b -> m ((TYPE Lifted :~: a) b)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (TYPE Lifted :~: a) b -> m ((TYPE Lifted :~: a) b)

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

gunfold :: (forall c r. Data c => c (c -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Coercion (TYPE Lifted) a b)

toConstr :: Coercion (TYPE Lifted) a b -> Constr

dataTypeOf :: Coercion (TYPE Lifted) a b -> DataType

dataCast1 :: Typeable (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c (Coercion (TYPE Lifted) a b))

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

gmapT :: (forall c. Data c => c -> c) -> Coercion (TYPE Lifted) a b -> Coercion (TYPE Lifted) a b

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Coercion (TYPE Lifted) a b -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Coercion (TYPE Lifted) a b -> r

gmapQ :: (forall d. Data d => d -> u) -> Coercion (TYPE Lifted) a b -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Coercion (TYPE Lifted) a b -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Coercion (TYPE Lifted) a b -> m (Coercion (TYPE Lifted) a b)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Coercion (TYPE Lifted) a b -> m (Coercion (TYPE Lifted) a b)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Coercion (TYPE Lifted) a b -> m (Coercion (TYPE Lifted) a b)

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

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Alt (TYPE Lifted) f a)

toConstr :: Alt (TYPE Lifted) f a -> Constr

dataTypeOf :: Alt (TYPE Lifted) f a -> DataType

dataCast1 :: Typeable (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c (Alt (TYPE Lifted) f a))

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

gmapT :: (forall b. Data b => b -> b) -> Alt (TYPE Lifted) f a -> Alt (TYPE Lifted) f a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Alt (TYPE Lifted) f a -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Alt (TYPE Lifted) f a -> r

gmapQ :: (forall d. Data d => d -> u) -> Alt (TYPE Lifted) f a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Alt (TYPE Lifted) f a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Alt (TYPE Lifted) f a -> m (Alt (TYPE Lifted) f a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Alt (TYPE Lifted) f a -> m (Alt (TYPE Lifted) f a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Alt (TYPE Lifted) f a -> m (Alt (TYPE Lifted) f a)

(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

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

(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

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

(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

(Applicative f, Applicative g) => Applicative (Product (TYPE Lifted) f g) 

Methods

pure :: a -> Product (TYPE Lifted) f g a

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

(*>) :: Product (TYPE Lifted) f g a -> Product (TYPE Lifted) f g b -> Product (TYPE Lifted) f g b

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

(Foldable f, Foldable g) => Foldable (Product (TYPE Lifted) f g) 

Methods

fold :: Monoid m => Product (TYPE Lifted) f g m -> m

foldMap :: Monoid m => (a -> m) -> Product (TYPE Lifted) f g a -> m

foldr :: (a -> b -> b) -> b -> Product (TYPE Lifted) f g a -> b

foldr' :: (a -> b -> b) -> b -> Product (TYPE Lifted) f g a -> b

foldl :: (b -> a -> b) -> b -> Product (TYPE Lifted) f g a -> b

foldl' :: (b -> a -> b) -> b -> Product (TYPE Lifted) f g a -> b

foldr1 :: (a -> a -> a) -> Product (TYPE Lifted) f g a -> a

foldl1 :: (a -> a -> a) -> Product (TYPE Lifted) f g a -> a

toList :: Product (TYPE Lifted) f g a -> [a]

null :: Product (TYPE Lifted) f g a -> Bool

length :: Product (TYPE Lifted) f g a -> Int

elem :: Eq a => a -> Product (TYPE Lifted) f g a -> Bool

maximum :: Ord a => Product (TYPE Lifted) f g a -> a

minimum :: Ord a => Product (TYPE Lifted) f g a -> a

sum :: Num a => Product (TYPE Lifted) f g a -> a

product :: Num a => Product (TYPE Lifted) f g a -> a

(Foldable f, Foldable g) => Foldable (Sum (TYPE Lifted) f g) 

Methods

fold :: Monoid m => Sum (TYPE Lifted) f g m -> m

foldMap :: Monoid m => (a -> m) -> Sum (TYPE Lifted) f g a -> m

foldr :: (a -> b -> b) -> b -> Sum (TYPE Lifted) f g a -> b

foldr' :: (a -> b -> b) -> b -> Sum (TYPE Lifted) f g a -> b

foldl :: (b -> a -> b) -> b -> Sum (TYPE Lifted) f g a -> b

foldl' :: (b -> a -> b) -> b -> Sum (TYPE Lifted) f g a -> b

foldr1 :: (a -> a -> a) -> Sum (TYPE Lifted) f g a -> a

foldl1 :: (a -> a -> a) -> Sum (TYPE Lifted) f g a -> a

toList :: Sum (TYPE Lifted) f g a -> [a]

null :: Sum (TYPE Lifted) f g a -> Bool

length :: Sum (TYPE Lifted) f g a -> Int

elem :: Eq a => a -> Sum (TYPE Lifted) f g a -> Bool

maximum :: Ord a => Sum (TYPE Lifted) f g a -> a

minimum :: Ord a => Sum (TYPE Lifted) f g a -> a

sum :: Num a => Sum (TYPE Lifted) f g a -> a

product :: Num a => Sum (TYPE Lifted) f g a -> a

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

sequenceA :: Applicative f => Product (TYPE Lifted) f g (f a) -> f (Product (TYPE Lifted) f g a)

mapM :: Monad m => (a -> m b) -> Product (TYPE Lifted) f g a -> m (Product (TYPE Lifted) f g b)

sequence :: Monad m => Product (TYPE Lifted) f g (m a) -> m (Product (TYPE Lifted) f g a)

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

sequenceA :: Applicative f => Sum (TYPE Lifted) f g (f a) -> f (Sum (TYPE Lifted) f g a)

mapM :: Monad m => (a -> m b) -> Sum (TYPE Lifted) f g a -> m (Sum (TYPE Lifted) f g b)

sequence :: Monad m => Sum (TYPE Lifted) f g (m a) -> m (Sum (TYPE Lifted) f g a)

Generic1 (Product (TYPE Lifted) f g) 

Associated Types

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

Methods

from1 :: Product (TYPE Lifted) f g a -> Rep1 (Product (TYPE Lifted) f g) a

to1 :: Rep1 (Product (TYPE Lifted) f g) a -> Product (TYPE Lifted) f g a

Generic1 (Sum (TYPE Lifted) f g) 

Associated Types

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

Methods

from1 :: Sum (TYPE Lifted) f g a -> Rep1 (Sum (TYPE Lifted) f g) a

to1 :: Rep1 (Sum (TYPE Lifted) f g) a -> Sum (TYPE Lifted) f g a

Alternative f => Semigroup (Alt (TYPE Lifted) f a) 

Methods

(<>) :: Alt (TYPE Lifted) f a -> Alt (TYPE Lifted) f a -> Alt (TYPE Lifted) f a

sconcat :: NonEmpty (Alt (TYPE Lifted) f a) -> Alt (TYPE Lifted) f a

stimes :: Integral b => b -> Alt (TYPE Lifted) f a -> Alt (TYPE Lifted) f a

Alternative f => Monoid (Alt (TYPE Lifted) f a) 

Methods

mempty :: Alt (TYPE Lifted) f a

mappend :: Alt (TYPE Lifted) f a -> Alt (TYPE Lifted) f a -> Alt (TYPE Lifted) f a

mconcat :: [Alt (TYPE Lifted) f a] -> Alt (TYPE Lifted) f a

(MonadPlus f, MonadPlus g) => MonadPlus (Product (TYPE Lifted) f g) 

Methods

mzero :: Product (TYPE Lifted) f g a

mplus :: Product (TYPE Lifted) f g a -> Product (TYPE Lifted) f g a -> Product (TYPE Lifted) f g a

(Alternative f, Alternative g) => Alternative (Product (TYPE Lifted) f g) 

Methods

empty :: Product (TYPE Lifted) f g a

(<|>) :: Product (TYPE Lifted) f g a -> Product (TYPE Lifted) f g a -> Product (TYPE Lifted) f g a

some :: Product (TYPE Lifted) f g a -> Product (TYPE Lifted) f g [a]

many :: Product (TYPE Lifted) f g a -> Product (TYPE Lifted) f g [a]

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

mzipWith :: (a -> b -> c) -> Product (TYPE Lifted) f g a -> Product (TYPE Lifted) f g b -> Product (TYPE Lifted) f g c

munzip :: Product (TYPE Lifted) f g (a, b) -> (Product (TYPE Lifted) f g a, Product (TYPE Lifted) f g b)

(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

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

(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

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

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

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

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

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

(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

(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

(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

(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

(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

(<$) :: a -> Compose (TYPE Lifted) (TYPE Lifted) f g b -> Compose (TYPE Lifted) (TYPE Lifted) f g a

(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) 
(Read1 f, Read1 g, Read a) => Read (Sum (TYPE Lifted) f g a) 

Methods

readsPrec :: Int -> ReadS (Sum (TYPE Lifted) f g a)

readList :: ReadS [Sum (TYPE Lifted) f g a]

readPrec :: ReadPrec (Sum (TYPE Lifted) f g a)

readListPrec :: ReadPrec [Sum (TYPE Lifted) f g a]

(Show1 f, Show1 g, Show a) => Show (Product (TYPE Lifted) f g a) 

Methods

showsPrec :: Int -> Product (TYPE Lifted) f g a -> ShowS

show :: Product (TYPE Lifted) f g a -> String

showList :: [Product (TYPE Lifted) f g a] -> ShowS

(Show1 f, Show1 g, Show a) => Show (Sum (TYPE Lifted) f g a) 

Methods

showsPrec :: Int -> Sum (TYPE Lifted) f g a -> ShowS

show :: Sum (TYPE Lifted) f g a -> String

showList :: [Sum (TYPE Lifted) f g a] -> ShowS

(Applicative f, Applicative g) => Applicative (Compose (TYPE Lifted) (TYPE Lifted) f g) 

Methods

pure :: a -> Compose (TYPE Lifted) (TYPE Lifted) f g a

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

(*>) :: Compose (TYPE Lifted) (TYPE Lifted) f g a -> Compose (TYPE Lifted) (TYPE Lifted) f g b -> Compose (TYPE Lifted) (TYPE Lifted) f g b

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

(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

foldMap :: Monoid m => (a -> m) -> Compose (TYPE Lifted) (TYPE Lifted) f g a -> m

foldr :: (a -> b -> b) -> b -> Compose (TYPE Lifted) (TYPE Lifted) f g a -> b

foldr' :: (a -> b -> b) -> b -> Compose (TYPE Lifted) (TYPE Lifted) f g a -> b

foldl :: (b -> a -> b) -> b -> Compose (TYPE Lifted) (TYPE Lifted) f g a -> b

foldl' :: (b -> a -> b) -> b -> Compose (TYPE Lifted) (TYPE Lifted) f g a -> b

foldr1 :: (a -> a -> a) -> Compose (TYPE Lifted) (TYPE Lifted) f g a -> a

foldl1 :: (a -> a -> a) -> Compose (TYPE Lifted) (TYPE Lifted) f g a -> a

toList :: Compose (TYPE Lifted) (TYPE Lifted) f g a -> [a]

null :: Compose (TYPE Lifted) (TYPE Lifted) f g a -> Bool

length :: Compose (TYPE Lifted) (TYPE Lifted) f g a -> Int

elem :: Eq a => a -> Compose (TYPE Lifted) (TYPE Lifted) f g a -> Bool

maximum :: Ord a => Compose (TYPE Lifted) (TYPE Lifted) f g a -> a

minimum :: Ord a => Compose (TYPE Lifted) (TYPE Lifted) f g a -> a

sum :: Num a => Compose (TYPE Lifted) (TYPE Lifted) f g a -> a

product :: Num a => Compose (TYPE Lifted) (TYPE Lifted) f g a -> a

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

sequenceA :: Applicative f => Compose (TYPE Lifted) (TYPE Lifted) f g (f a) -> f (Compose (TYPE Lifted) (TYPE Lifted) f g a)

mapM :: Monad m => (a -> m b) -> Compose (TYPE Lifted) (TYPE Lifted) f g a -> m (Compose (TYPE Lifted) (TYPE Lifted) f g b)

sequence :: Monad m => Compose (TYPE Lifted) (TYPE Lifted) f g (m a) -> m (Compose (TYPE Lifted) (TYPE Lifted) f g a)

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

Associated Types

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

Methods

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

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

(Alternative f, Applicative g) => Alternative (Compose (TYPE Lifted) (TYPE Lifted) f g) 
(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

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Compose (TYPE Lifted) (TYPE Lifted) f g a] -> ShowS

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

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

(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

(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

(Eq1 f, Eq1 g, Eq a) => Eq (Compose (TYPE Lifted) (TYPE Lifted) f g a) 
(Ord1 f, Ord1 g, Ord a) => Ord (Compose (TYPE Lifted) (TYPE Lifted) f g a) 
(Read1 f, Read1 g, Read a) => Read (Compose (TYPE Lifted) (TYPE Lifted) f g a) 
(Show1 f, Show1 g, Show a) => Show (Compose (TYPE Lifted) (TYPE Lifted) f g a) 
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

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) 
Show a => Show (Down a) 

Methods

showsPrec :: Int -> Down a -> ShowS

show :: Down a -> String

showList :: [Down a] -> ShowS

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

The groupWith function uses the user supplied function which projects an element out of every list element in order to first sort the input list and then to form groups by equality on these projected elements

sortWith :: Ord b => (a -> b) -> [a] -> [a]

The sortWith function sorts a list of elements using the user supplied function to project something out of each element

the :: Eq a => [a] -> a

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

Event logging

traceEvent :: String -> IO ()

Deprecated: Use traceEvent or traceEventIO

SpecConstr annotations

data SpecConstrAnnotation

Instances

Eq SpecConstrAnnotation 
Data SpecConstrAnnotation 

Methods

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

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

toConstr :: SpecConstrAnnotation -> Constr

dataTypeOf :: SpecConstrAnnotation -> DataType

dataCast1 :: Typeable (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c SpecConstrAnnotation)

dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SpecConstrAnnotation)

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

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

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

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

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

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

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

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

The call stack

currentCallStack :: IO [String]

Returns a [String] representing the current call stack. This can be useful for debugging.

The implementation uses the call-stack simulation maintined by the profiler, so it only works if the program was compiled with -prof and contains suitable SCC annotations (e.g. by using -fprof-auto). Otherwise, the list returned is likely to be empty or uninformative.

Since: 4.5.0.0

The Constraint kind

data Constraint :: TYPE Lifted Source

The kind of constraints, like Show a

Overloaded lists

class IsList l where

The IsList class and its methods are intended to be used in conjunction with the OverloadedLists extension.

Since: 4.7.0.0

Minimal complete definition

fromList, toList

Associated Types

type Item l

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

Methods

fromList :: [Item l] -> l

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

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

The fromListN function takes the input list's length as a hint. Its behaviour should be equivalent to fromList. The hint can be used to construct the structure l more efficiently compared to fromList. If the given hint does not equal to the input list's length the behaviour of fromListN is not specified.

toList :: l -> [Item l]

The toList function extracts a list of Item l from the structure l. It should satisfy fromList . toList = id.

Instances

IsList Version

Since: 4.8.0.0

Associated Types

type Item Version :: TYPE Lifted

IsList [a] 

Associated Types

type Item [a] :: TYPE Lifted

Methods

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

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

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

IsList (NonEmpty a) 

Associated Types

type Item (NonEmpty a) :: TYPE Lifted

Methods

fromList :: [Item (NonEmpty a)] -> NonEmpty a

fromListN :: Int -> [Item (NonEmpty a)] -> NonEmpty a

toList :: NonEmpty a -> [Item (NonEmpty a)]