Safe Haskell	Safe-Inferred
Language	Haskell2010

Tests.Core.Imports

Synopsis

data Result
- = Success {
  - numTests :: Int
  - numDiscarded :: Int
  - labels :: !(Map [String] Int)
  - classes :: !(Map String Int)
  - tables :: !(Map String (Map String Int))
  - output :: String
  }
- | GaveUp {
  - numTests :: Int
  - numDiscarded :: Int
  - labels :: !(Map [String] Int)
  - classes :: !(Map String Int)
  - tables :: !(Map String (Map String Int))
  - output :: String
  }
- | Failure {
  - numTests :: Int
  - numDiscarded :: Int
  - numShrinks :: Int
  - numShrinkTries :: Int
  - numShrinkFinal :: Int
  - usedSeed :: QCGen
  - usedSize :: Int
  - reason :: String
  - theException :: Maybe AnException
  - output :: String
  - failingTestCase :: [String]
  - failingLabels :: [String]
  - failingClasses :: Set String
  - witnesses :: [Witness]
  }
- | NoExpectedFailure {
  - numTests :: Int
  - numDiscarded :: Int
  - labels :: !(Map [String] Int)
  - classes :: !(Map String Int)
  - tables :: !(Map String (Map String Int))
  - output :: String
  }
class Testable prop where
- property :: prop -> Property
- propertyForAllShrinkShow :: Gen a -> (a -> [a]) -> (a -> [String]) -> (a -> prop) -> Property
type ShowS = String -> String
type String = [Char]
data FUN
data Bool
- = False
- | True
data Char
data Double
data Float
data Int
data Word
data Ordering
- = LT
- | EQ
- | GT
data Maybe a
- = Nothing
- | Just a
class a ~# b => (a :: k) ~ (b :: k)
data Integer
data IO a
type Type = TYPE LiftedRep
type Constraint = CONSTRAINT LiftedRep
class Show a where
- showsPrec :: Int -> a -> ShowS
- show :: a -> String
- showList :: [a] -> ShowS
class Semigroup a => Monoid a where
- mempty :: a
- mappend :: a -> a -> a
- mconcat :: [a] -> a
class Semigroup a where
- (<>) :: a -> a -> a
class Functor f => Applicative (f :: Type -> Type) where
- pure :: a -> f a
- (<*>) :: f (a -> b) -> f a -> f b
- liftA2 :: (a -> b -> c) -> f a -> f b -> f c
- (*>) :: f a -> f b -> f b
- (<*) :: f a -> f b -> f a
class Functor (f :: Type -> Type) where
- fmap :: (a -> b) -> f a -> f b
- (<$) :: a -> f b -> f a
class Applicative m => Monad (m :: Type -> Type) where
- (>>=) :: m a -> (a -> m b) -> m b
- (>>) :: m a -> m b -> m b
- return :: a -> m a
data Fun a b = Fun (a :-> b, b, Shrunk) (a -> b)
data Gen a
class CoArbitrary a where
- coarbitrary :: a -> Gen b -> Gen b
class Arbitrary2 (f :: Type -> Type -> Type) where
- liftArbitrary2 :: Gen a -> Gen b -> Gen (f a b)
- liftShrink2 :: (a -> [a]) -> (b -> [b]) -> f a b -> [f a b]
class Arbitrary1 (f :: Type -> Type) where
- liftArbitrary :: Gen a -> Gen (f a)
- liftShrink :: (a -> [a]) -> f a -> [f a]
class Arbitrary a where
- arbitrary :: Gen a
- shrink :: a -> [a]
newtype PrintableString = PrintableString {
- getPrintableString :: String
}
newtype UnicodeString = UnicodeString {
- getUnicodeString :: String
}
newtype ASCIIString = ASCIIString {
- getASCIIString :: String
}
class ShrinkState s a where
- shrinkInit :: a -> s
- shrinkState :: a -> s -> [(a, s)]
data Shrinking s a = Shrinking s a
data Smart a = Smart Int a
newtype Shrink2 a = Shrink2 {
- getShrink2 :: a
}
newtype Small a = Small {
- getSmall :: a
}
newtype Large a = Large {
- getLarge :: a
}
newtype NonPositive a = NonPositive {
- getNonPositive :: a
}
newtype NonNegative a = NonNegative {
- getNonNegative :: a
}
newtype NonZero a = NonZero {
- getNonZero :: a
}
newtype Negative a = Negative {
- getNegative :: a
}
newtype Positive a = Positive {
- getPositive :: a
}
newtype SortedList a = Sorted {
- getSorted :: [a]
}
data InfiniteList a = InfiniteList {
- getInfiniteList :: [a]
- infiniteListInternalData :: InfiniteListInternalData a
}
newtype NonEmptyList a = NonEmpty {
- getNonEmpty :: [a]
}
newtype OrderedList a = Ordered {
- getOrdered :: [a]
}
newtype Fixed a = Fixed {
- getFixed :: a
}
newtype Blind a = Blind {
- getBlind :: a
}
class Function a where
- function :: (a -> b) -> a :-> b
data Confidence = Confidence {
- certainty :: Integer
- tolerance :: Double
}
data Witness = (Typeable a, Show a) => Wit a
data Discard = Discard
data Property
data Args = Args {
- replay :: Maybe (QCGen, Int)
- maxSuccess :: Int
- maxDiscardRatio :: Int
- maxSize :: Int
- chatty :: Bool
- maxShrinks :: Int
}
newtype PropertyM (m :: Type -> Type) a = MkPropertyM {
- unPropertyM :: (a -> Gen (m Property)) -> Gen (m Property)
}
class Bounded a where
- minBound :: a
- maxBound :: a
class Enum a where
- succ :: a -> a
- pred :: a -> a
- toEnum :: Int -> a
- fromEnum :: a -> Int
- enumFrom :: a -> [a]
- enumFromThen :: a -> a -> [a]
- enumFromTo :: a -> a -> [a]
- enumFromThenTo :: a -> a -> a -> [a]
class (Real a, Fractional a) => RealFrac a where
- properFraction :: Integral b => a -> (b, a)
- truncate :: Integral b => a -> b
- round :: Integral b => a -> b
- ceiling :: Integral b => a -> b
- floor :: Integral b => a -> b
class (Real a, Enum a) => Integral a where
- quot :: a -> a -> a
- rem :: a -> a -> a
- div :: a -> a -> a
- mod :: a -> a -> a
- quotRem :: a -> a -> (a, a)
- divMod :: a -> a -> (a, a)
- toInteger :: a -> Integer
class Read a where
- readsPrec :: Int -> ReadS a
- readList :: ReadS [a]
class Eq a => Ord a where
- compare :: a -> a -> Ordering
- (<) :: a -> a -> Bool
- (<=) :: a -> a -> Bool
- (>) :: a -> a -> Bool
- (>=) :: a -> a -> Bool
- max :: a -> a -> a
- min :: a -> a -> a
type Selector a = a -> Bool
newtype S = S WORD
newtype R = R WORD
type Rational = Ratio Integer
class Num a => Fractional a where
- (/) :: a -> a -> a
- recip :: a -> a
- fromRational :: Rational -> a
class (Num a, Ord a) => Real a where
- toRational :: a -> Rational
class Eq a where
- (==) :: a -> a -> Bool
- (/=) :: a -> a -> Bool
data Word8
data Handle
data Word64
data Word32
data Word16
data Either a b
- = Left a
- | Right b
class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type) where
- mzero :: m a
- mplus :: m a -> m a -> m a
class Storable a where
- peek :: Ptr a -> IO a
- poke :: Ptr a -> a -> IO ()
data Ptr a
data TextEncoding
type IOError = IOException
class Fractional a => Floating a where
- pi :: a
- exp :: a -> a
- log :: a -> a
- sqrt :: a -> a
- (**) :: a -> a -> a
- logBase :: a -> a -> a
- sin :: a -> a
- cos :: a -> a
- tan :: a -> a
- asin :: a -> a
- acos :: a -> a
- atan :: a -> a
- sinh :: a -> a
- cosh :: a -> a
- tanh :: a -> a
- asinh :: a -> a
- acosh :: a -> a
- atanh :: a -> a
class Num a where
- (+) :: a -> a -> a
- (-) :: a -> a -> a
- (*) :: a -> a -> a
- negate :: a -> a
- abs :: a -> a
- signum :: a -> a
- fromInteger :: Integer -> a
class (RealFrac a, Floating a) => RealFloat a where
- floatRadix :: a -> Integer
- floatDigits :: a -> Int
- floatRange :: a -> (Int, Int)
- decodeFloat :: a -> (Integer, Int)
- encodeFloat :: Integer -> Int -> a
- exponent :: a -> Int
- significand :: a -> a
- scaleFloat :: Int -> a -> a
- isNaN :: a -> Bool
- isInfinite :: a -> Bool
- isDenormalized :: a -> Bool
- isNegativeZero :: a -> Bool
- isIEEE :: a -> Bool
- atan2 :: a -> a -> a
class Monad m => MonadFail (m :: Type -> Type) where
- fail :: String -> m a
class IsString a where
- fromString :: String -> a
class Foldable (t :: Type -> Type) where
- foldMap :: Monoid m => (a -> m) -> t a -> m
- foldr :: (a -> b -> b) -> b -> t a -> b
- foldl :: (b -> a -> b) -> b -> t a -> b
- foldr1 :: (a -> a -> a) -> t a -> a
- foldl1 :: (a -> a -> a) -> t a -> a
- null :: t a -> Bool
- elem :: Eq a => a -> t a -> Bool
- maximum :: Ord a => t a -> a
- minimum :: Ord a => t a -> a
- sum :: Num a => t a -> a
- product :: Num a => t a -> a
class (Functor t, Foldable t) => Traversable (t :: Type -> Type) where
- traverse :: Applicative f => (a -> f b) -> t a -> f (t b)
- sequenceA :: Applicative f => t (f a) -> f (t a)
- mapM :: Monad m => (a -> m b) -> t a -> m (t b)
- sequence :: Monad m => t (m a) -> m (t a)
type HasCallStack = ?callStack :: CallStack
class Applicative f => Alternative (f :: Type -> Type) where
- empty :: f a
- (<|>) :: f a -> f a -> f a
- some :: f a -> f [a]
- many :: f a -> f [a]
class Bits b => FiniteBits b where
- finiteBitSize :: b -> Int
- countLeadingZeros :: b -> Int
- countTrailingZeros :: b -> Int
class Eq a => Bits a where
- (.|.) :: a -> a -> a
- xor :: a -> a -> a
- complement :: a -> a
- shift :: a -> Int -> a
- rotate :: a -> Int -> a
- zeroBits :: a
- bit :: Int -> a
- setBit :: a -> Int -> a
- clearBit :: a -> Int -> a
- complementBit :: a -> Int -> a
- testBit :: a -> Int -> Bool
- bitSizeMaybe :: a -> Maybe Int
- bitSize :: a -> Int
- isSigned :: a -> Bool
- shiftL :: a -> Int -> a
- unsafeShiftL :: a -> Int -> a
- shiftR :: a -> Int -> a
- unsafeShiftR :: a -> Int -> a
- rotateL :: a -> Int -> a
- rotateR :: a -> Int -> a
- popCount :: a -> Int
class (IsString fmt, Show fmt, Encodable fmt) => Format fmt where
- encodeByteString :: ByteString -> fmt
- decodeFormat :: fmt -> ByteString
type ReadS a = String -> [(a, String)]
newtype Iff a = Iff {
- getIff :: a
}
newtype Xor a = Xor {
- getXor :: a
}
newtype Ior a = Ior {
- getIor :: a
}
newtype And a = And {
- getAnd :: a
}
data KProxy t = KProxy
data Proxy (t :: k) = Proxy
data IOMode
- = ReadMode
- | WriteMode
- | AppendMode
- | ReadWriteMode
newtype Const a (b :: k) = Const {
- getConst :: a
}
type FilePath = String
data SeekMode
- = AbsoluteSeek
- | RelativeSeek
- | SeekFromEnd
data NewlineMode = NewlineMode {
- inputNL :: Newline
- outputNL :: Newline
}
data Newline
- = LF
- | CRLF
data BufferMode
- = NoBuffering
- | LineBuffering
- | BlockBuffering (Maybe Int)
data HandlePosn
newtype ZipList a = ZipList {
- getZipList :: [a]
}
newtype WrappedArrow (a :: Type -> Type -> Type) b c = WrapArrow {
- unwrapArrow :: a b c
}
newtype WrappedMonad (m :: Type -> Type) a = WrapMonad {
- unwrapMonad :: m a
}
class Example e where
- type Arg e
type family Arg e
data family Key p
data ByteString
type ActionWith a = a -> IO ()
type SpecWith a = SpecM a ()
type Spec = SpecWith ()
type Expectation = Assertion
data Tuple (dim :: Nat) a
class (Unbox (WordType p), EndianStore (WordType p), KnownNat (WordsPerBlock p)) => Primitive p where
- type WordType p
- type WordsPerBlock p :: Nat
newtype Poly1305 = Poly1305 WORD
data BYTES a
class ByteSource src where
- fillBytes :: BYTES Int -> src -> Ptr a -> IO (FillResult src)
data FillResult a
- = Remaining a
- | Exhausted (BYTES Int)
class ByteSource src => PureByteSource src
data Base16
data Base64
class Encodable a where
- toByteString :: a -> ByteString
- fromByteString :: ByteString -> Maybe a
- unsafeFromByteString :: ByteString -> a
data Access
type Alloc mem = TwistRF AllocField (BYTES Int) mem
class Memory m => Extractable m v where
- extract :: m -> IO v
class Memory m => Initialisable m v where
- initialise :: v -> m -> IO ()
class Memory m where
- memoryAlloc :: Alloc m
- unsafeToPointer :: m -> Ptr Word8
data MemoryCell a
class Memory mem => ReadAccessible mem where
- beforeReadAdjustment :: mem -> IO ()
- readAccess :: mem -> [Access]
data VoidMemory
class Memory mem => WriteAccessible mem where
- writeAccess :: mem -> [Access]
- afterWriteAdjustment :: mem -> IO ()
type AlignedBlockPtr (n :: Nat) p = AlignedPtr n (Block p)
type Block p = Tuple (WordsPerBlock p) (WordType p)
newtype BlockCount p = BlockCount {
- unBlockCount :: Int
}
type BlockPtr p = Ptr (Block p)
data family Nounce p
type family WordType p
type family WordsPerBlock p :: Nat
type ReadFrom = Transfer 'ReadFromBuffer
type Transfer (t :: Mode) = SemiR (TransferAction t) (BYTES Int)
type WriteTo = Transfer 'WriteToBuffer
data Dest a
data Src a
data BE w
class Storable w => EndianStore w where
- store :: Ptr w -> w -> IO ()
- load :: Ptr w -> IO w
- adjustEndian :: Ptr w -> Int -> IO ()
data LE w
class Equality a where
- eq :: a -> a -> Result
data AlignedPtr (n :: Nat) a
class (Enum u, Monoid u) => LengthUnit u where
- inBytes :: u -> BYTES Int
class Pointer (ptr :: Type -> Type) where
- castPointer :: ptr a -> ptr b
- allocaPointer :: BYTES Int -> (ptr a -> IO b) -> IO b
- unsafeRawPtr :: ptr a -> Ptr a
type Dimension (dim :: Nat) = KnownNat dim
type Blake2b = Blake2 (LE Word64)
type Blake2bMem = HashMemory128 Blake2b
type Blake2s = Blake2 (LE Word32)
type Blake2sMem = HashMemory64 Blake2s
data ChaCha20 = ChaCha20
data XChaCha20 = XChaCha20
data ChaCha20Mem = ChaCha20Mem {
- keyCell :: MemoryCell (Key ChaCha20)
- ivCell :: MemoryCell (Nounce ChaCha20)
- counterCell :: MemoryCell WORD
}
type WORD = Tuple 2 (LE Word64)
type Sha256 = Sha2 (BE Word32)
type Sha256Mem = HashMemory64 Sha256
type Sha512 = Sha2 (BE Word64)
type Sha512Mem = HashMemory128 Sha512
pattern Fn3 :: (a -> b -> c -> d) -> Fun (a, b, c) d
pattern Fn2 :: (a -> b -> c) -> Fun (a, b) c
pattern Fn :: (a -> b) -> Fun a b
hspec :: Spec -> IO ()
vector :: Arbitrary a => Int -> Gen [a]
assert :: forall (m :: Type -> Type). Monad m => Bool -> PropertyM m ()
(==>) :: Testable prop => Bool -> prop -> Property
($) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
otherwise :: Bool
(++) :: [a] -> [a] -> [a]
map :: (a -> b) -> [a] -> [b]
join :: Monad m => m (m a) -> m a
discard :: a
variant :: Integral n => n -> Gen a -> Gen a
sized :: (Int -> Gen a) -> Gen a
getSize :: Gen Int
resize :: HasCallStack => Int -> Gen a -> Gen a
scale :: (Int -> Int) -> Gen a -> Gen a
choose :: Random a => (a, a) -> Gen a
chooseAny :: Random a => Gen a
chooseEnum :: Enum a => (a, a) -> Gen a
chooseInt :: (Int, Int) -> Gen Int
chooseBoundedIntegral :: (Bounded a, Integral a) => (a, a) -> Gen a
chooseInteger :: (Integer, Integer) -> Gen Integer
generate :: Gen a -> IO a
sample' :: Gen a -> IO [a]
sample :: Show a => Gen a -> IO ()
suchThat :: Gen a -> (a -> Bool) -> Gen a
suchThatMap :: Gen a -> (a -> Maybe b) -> Gen b
suchThatMaybe :: Gen a -> (a -> Bool) -> Gen (Maybe a)
oneof :: HasCallStack => [Gen a] -> Gen a
frequency :: HasCallStack => [(Int, Gen a)] -> Gen a
elements :: HasCallStack => [a] -> Gen a
sublistOf :: [a] -> Gen [a]
shuffle :: [a] -> Gen [a]
growingElements :: HasCallStack => [a] -> Gen a
listOf :: Gen a -> Gen [a]
listOf1 :: Gen a -> Gen [a]
vectorOf :: Int -> Gen a -> Gen [a]
infiniteListOf :: Gen a -> Gen [a]
arbitrary1 :: (Arbitrary1 f, Arbitrary a) => Gen (f a)
shrink1 :: (Arbitrary1 f, Arbitrary a) => f a -> [f a]
arbitrary2 :: (Arbitrary2 f, Arbitrary a, Arbitrary b) => Gen (f a b)
shrink2 :: (Arbitrary2 f, Arbitrary a, Arbitrary b) => f a b -> [f a b]
genericShrink :: (Generic a, RecursivelyShrink (Rep a), GSubterms (Rep a) a) => a -> [a]
recursivelyShrink :: (Generic a, RecursivelyShrink (Rep a)) => a -> [a]
subterms :: (Generic a, GSubterms (Rep a) a) => a -> [a]
shrinkList :: (a -> [a]) -> [a] -> [[a]]
applyArbitrary2 :: (Arbitrary a, Arbitrary b) => (a -> b -> r) -> Gen r
applyArbitrary3 :: (Arbitrary a, Arbitrary b, Arbitrary c) => (a -> b -> c -> r) -> Gen r
applyArbitrary4 :: (Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d) => (a -> b -> c -> d -> r) -> Gen r
arbitrarySizedIntegral :: Integral a => Gen a
arbitrarySizedNatural :: Integral a => Gen a
arbitrarySizedFractional :: Fractional a => Gen a
arbitraryBoundedIntegral :: (Bounded a, Integral a) => Gen a
arbitraryBoundedRandom :: (Bounded a, Random a) => Gen a
arbitraryBoundedEnum :: (Bounded a, Enum a) => Gen a
arbitrarySizedBoundedIntegral :: (Bounded a, Integral a) => Gen a
arbitraryUnicodeChar :: Gen Char
arbitraryASCIIChar :: Gen Char
arbitraryPrintableChar :: Gen Char
shrinkNothing :: a -> [a]
shrinkMap :: Arbitrary a => (a -> b) -> (b -> a) -> b -> [b]
shrinkMapBy :: (a -> b) -> (b -> a) -> (a -> [a]) -> b -> [b]
shrinkIntegral :: Integral a => a -> [a]
shrinkBoundedEnum :: (Bounded a, Enum a, Eq a) => a -> [a]
shrinkRealFrac :: RealFrac a => a -> [a]
shrinkDecimal :: RealFrac a => a -> [a]
genericCoarbitrary :: (Generic a, GCoArbitrary (Rep a)) => a -> Gen b -> Gen b
(><) :: (Gen a -> Gen a) -> (Gen a -> Gen a) -> Gen a -> Gen a
coarbitraryIntegral :: Integral a => a -> Gen b -> Gen b
coarbitraryReal :: Real a => a -> Gen b -> Gen b
coarbitraryShow :: Show a => a -> Gen b -> Gen b
coarbitraryEnum :: Enum a => a -> Gen b -> Gen b
orderedList :: (Ord a, Arbitrary a) => Gen [a]
infiniteList :: Arbitrary a => Gen [a]
functionBoundedEnum :: (Eq a, Bounded a, Enum a) => (a -> b) -> a :-> b
functionRealFrac :: RealFrac a => (a -> b) -> a :-> b
functionIntegral :: Integral a => (a -> b) -> a :-> b
functionShow :: (Show a, Read a) => (a -> c) -> a :-> c
functionVoid :: (forall b. void -> b) -> void :-> c
functionMap :: Function b => (a -> b) -> (b -> a) -> (a -> c) -> a :-> c
applyFun :: Fun a b -> a -> b
applyFun2 :: Fun (a, b) c -> a -> b -> c
applyFun3 :: Fun (a, b, c) d -> a -> b -> c -> d
ioProperty :: Testable prop => IO prop -> Property
idempotentIOProperty :: Testable prop => IO prop -> Property
coerceWitness :: Typeable a => Witness -> a
castWitness :: Typeable a => Witness -> Maybe a
mapSize :: Testable prop => (Int -> Int) -> prop -> Property
shrinking :: Testable prop => (a -> [a]) -> a -> (a -> prop) -> Property
noShrinking :: Testable prop => prop -> Property
counterexample :: Testable prop => String -> prop -> Property
printTestCase :: Testable prop => String -> prop -> Property
whenFail :: Testable prop => IO () -> prop -> Property
whenFail' :: Testable prop => IO () -> prop -> Property
verbose :: Testable prop => prop -> Property
verboseShrinking :: Testable prop => prop -> Property
expectFailure :: Testable prop => prop -> Property
once :: Testable prop => prop -> Property
again :: Testable prop => prop -> Property
withMaxSuccess :: Testable prop => Int -> prop -> Property
withDiscardRatio :: Testable prop => Int -> prop -> Property
withMaxShrinks :: Testable prop => Int -> prop -> Property
withMaxSize :: Testable prop => Int -> prop -> Property
witness :: (Typeable a, Show a, Testable prop) => a -> prop -> Property
checkCoverage :: Testable prop => prop -> Property
checkCoverageWith :: Testable prop => Confidence -> prop -> Property
stdConfidence :: Confidence
label :: Testable prop => String -> prop -> Property
collect :: (Show a, Testable prop) => a -> prop -> Property
classify :: Testable prop => Bool -> String -> prop -> Property
cover :: Testable prop => Double -> Bool -> String -> prop -> Property
tabulate :: Testable prop => String -> [String] -> prop -> Property
coverTable :: Testable prop => String -> [(String, Double)] -> prop -> Property
within :: Testable prop => Int -> prop -> Property
discardAfter :: Testable prop => Int -> prop -> Property
forAll :: (Show a, Testable prop) => Gen a -> (a -> prop) -> Property
forAllShow :: Testable prop => Gen a -> (a -> String) -> (a -> prop) -> Property
forAllBlind :: Testable prop => Gen a -> (a -> prop) -> Property
forAllShrink :: (Show a, Testable prop) => Gen a -> (a -> [a]) -> (a -> prop) -> Property
forAllShrinkShow :: Testable prop => Gen a -> (a -> [a]) -> (a -> String) -> (a -> prop) -> Property
forAllShrinkBlind :: Testable prop => Gen a -> (a -> [a]) -> (a -> prop) -> Property
(.&.) :: (Testable prop1, Testable prop2) => prop1 -> prop2 -> Property
(.&&.) :: (Testable prop1, Testable prop2) => prop1 -> prop2 -> Property
conjoin :: Testable prop => [prop] -> Property
(.||.) :: (Testable prop1, Testable prop2) => prop1 -> prop2 -> Property
disjoin :: Testable prop => [prop] -> Property
(===) :: (Eq a, Show a) => a -> a -> Property
(=/=) :: (Eq a, Show a) => a -> a -> Property
total :: NFData a => a -> Property
isSuccess :: Result -> Bool
stdArgs :: Args
quickCheck :: Testable prop => prop -> IO ()
quickCheckWith :: Testable prop => Args -> prop -> IO ()
quickCheckResult :: Testable prop => prop -> IO Result
quickCheckWithResult :: Testable prop => Args -> prop -> IO Result
recheck :: Testable prop => Result -> prop -> IO ()
verboseCheck :: Testable prop => prop -> IO ()
verboseCheckWith :: Testable prop => Args -> prop -> IO ()
verboseCheckResult :: Testable prop => prop -> IO Result
verboseCheckWithResult :: Testable prop => Args -> prop -> IO Result
stop :: forall prop (m :: Type -> Type) a. (Testable prop, Monad m) => prop -> PropertyM m a
assertWith :: forall (m :: Type -> Type). Monad m => Bool -> String -> PropertyM m ()
pre :: forall (m :: Type -> Type). Monad m => Bool -> PropertyM m ()
run :: Monad m => m a -> PropertyM m a
pick :: forall (m :: Type -> Type) a. (Monad m, Show a) => Gen a -> PropertyM m a
wp :: Monad m => m a -> (a -> PropertyM m b) -> PropertyM m b
forAllM :: forall (m :: Type -> Type) a b. (Monad m, Show a) => Gen a -> (a -> PropertyM m b) -> PropertyM m b
monitor :: forall (m :: Type -> Type). Monad m => (Property -> Property) -> PropertyM m ()
monadic :: (Testable a, Monad m) => (m Property -> Property) -> PropertyM m a -> Property
monadic' :: (Testable a, Monad m) => PropertyM m a -> Gen (m Property)
monadicIO :: Testable a => PropertyM IO a -> Property
monadicST :: Testable a => (forall s. PropertyM (ST s) a) -> Property
runSTGen :: (forall s. Gen (ST s a)) -> Gen a
assertException :: Exception exc => (exc -> Bool) -> a -> Property
assertExceptionIO :: Exception exc => (exc -> Bool) -> IO a -> Property
assertDeepException :: (NFData a, Exception exc) => (exc -> Bool) -> a -> Property
assertDeepExceptionIO :: (NFData a, Exception exc) => (exc -> Bool) -> IO a -> Property
polyQuickCheck :: Name -> ExpQ
polyVerboseCheck :: Name -> ExpQ
monomorphic :: Name -> ExpQ
forAllProperties :: Q Exp
allProperties :: Q Exp
quickCheckAll :: Q Exp
verboseCheckAll :: Q Exp
labelledExamples :: Testable prop => prop -> IO ()
labelledExamplesWith :: Testable prop => Args -> prop -> IO ()
labelledExamplesResult :: Testable prop => prop -> IO Result
labelledExamplesWithResult :: Testable prop => Args -> prop -> IO Result
realToFrac :: (Real a, Fractional b) => a -> b
fromIntegral :: (Integral a, Num b) => a -> b
hIsTerminalDevice :: Handle -> IO Bool
stdout :: Handle
stdin :: Handle
error :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => [Char] -> a
zipWith :: forall a b c (dim :: Nat). (Unbox a, Unbox b, Unbox c) => (a -> b -> c) -> Tuple dim a -> Tuple dim b -> Tuple dim c
even :: Integral a => a -> Bool
(<$>) :: Functor f => (a -> b) -> f a -> f b
hGetContents :: Handle -> IO String
fst :: (a, b) -> a
uncurry :: (a -> b -> c) -> (a, b) -> c
openFile :: FilePath -> IOMode -> IO Handle
length :: ByteString -> BYTES Int
id :: a -> a
head :: HasCallStack => [a] -> a
forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b)
stderr :: Handle
forever :: Applicative f => f a -> f b
utf8 :: TextEncoding
mkTextEncoding :: String -> IO TextEncoding
hSeek :: Handle -> SeekMode -> Integer -> IO ()
hFlush :: Handle -> IO ()
hLookAhead :: Handle -> IO Char
fixIO :: (a -> IO a) -> IO a
sizeOf :: Storable a => Proxy a -> BYTES Int
readFile' :: FilePath -> IO String
writeFile :: FilePath -> String -> IO ()
getLine :: IO String
putStrLn :: String -> IO ()
hClose :: Handle -> IO ()
hSetBinaryMode :: Handle -> Bool -> IO ()
localeEncoding :: TextEncoding
liftM :: Monad m => (a1 -> r) -> m a1 -> m r
filter :: (a -> Bool) -> [a] -> [a]
hGetBuf :: Handle -> Ptr a -> Int -> IO Int
hPutBuf :: Handle -> Ptr a -> Int -> IO ()
hWaitForInput :: Handle -> Int -> IO Bool
cycle :: HasCallStack => [a] -> [a]
seq :: forall {r :: RuntimeRep} a (b :: TYPE r). a -> b -> b
concat :: Foldable t => t [a] -> [a]
zip :: [a] -> [b] -> [(a, b)]
print :: Show a => a -> IO ()
guard :: Alternative f => Bool -> f ()
(^) :: (Num a, Integral b) => a -> b -> a
(&&) :: Bool -> Bool -> Bool
(||) :: Bool -> Bool -> Bool
not :: Bool -> Bool
errorWithoutStackTrace :: forall (r :: RuntimeRep) (a :: TYPE r). [Char] -> a
undefined :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => a
(<**>) :: Applicative f => f a -> f (a -> b) -> f b
liftA :: Applicative f => (a -> b) -> f a -> f b
liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d
(=<<) :: Monad m => (a -> m b) -> m a -> m b
when :: Applicative f => Bool -> f () -> f ()
liftM2 :: Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM3 :: Monad m => (a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r
liftM4 :: Monad m => (a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r
liftM5 :: Monad m => (a1 -> a2 -> a3 -> a4 -> a5 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r
ap :: Monad m => m (a -> b) -> m a -> m b
const :: a -> b -> a
(.) :: (b -> c) -> (a -> b) -> a -> c
flip :: (a -> b -> c) -> b -> a -> c
($!) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
until :: (a -> Bool) -> (a -> a) -> a -> a
asTypeOf :: a -> a -> a
subtract :: Num a => a -> a -> a
maybe :: b -> (a -> b) -> Maybe a -> b
isJust :: Maybe a -> Bool
isNothing :: Maybe a -> Bool
fromJust :: HasCallStack => Maybe a -> a
fromMaybe :: a -> Maybe a -> a
maybeToList :: Maybe a -> [a]
listToMaybe :: [a] -> Maybe a
catMaybes :: [Maybe a] -> [a]
mapMaybe :: (a -> Maybe b) -> [a] -> [b]
tail :: HasCallStack => [a] -> [a]
last :: HasCallStack => [a] -> a
init :: HasCallStack => [a] -> [a]
scanl :: (b -> a -> b) -> b -> [a] -> [b]
scanl1 :: (a -> a -> a) -> [a] -> [a]
scanr :: (a -> b -> b) -> b -> [a] -> [b]
scanr1 :: (a -> a -> a) -> [a] -> [a]
iterate :: (a -> a) -> a -> [a]
repeat :: a -> [a]
replicate :: LengthUnit l => l -> Word8 -> ByteString
takeWhile :: (a -> Bool) -> [a] -> [a]
dropWhile :: (a -> Bool) -> [a] -> [a]
take :: Int -> [a] -> [a]
drop :: Int -> [a] -> [a]
splitAt :: Int -> [a] -> ([a], [a])
span :: (a -> Bool) -> [a] -> ([a], [a])
break :: (a -> Bool) -> [a] -> ([a], [a])
reverse :: [a] -> [a]
and :: Foldable t => t Bool -> Bool
or :: Foldable t => t Bool -> Bool
any :: Foldable t => (a -> Bool) -> t a -> Bool
all :: Foldable t => (a -> Bool) -> t a -> Bool
notElem :: (Foldable t, Eq a) => a -> t a -> Bool
lookup :: Eq a => a -> [(a, b)] -> Maybe b
concatMap :: Foldable t => (a -> [b]) -> t a -> [b]
(!!) :: HasCallStack => [a] -> Int -> a
zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]
zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
unzip :: [(a, b)] -> ([a], [b])
unzip3 :: [(a, b, c)] -> ([a], [b], [c])
shows :: Show a => a -> ShowS
showChar :: Char -> ShowS
showString :: String -> ShowS
showParen :: Bool -> ShowS -> ShowS
odd :: Integral a => a -> Bool
(^^) :: (Fractional a, Integral b) => a -> b -> a
gcd :: Integral a => a -> a -> a
lcm :: Integral a => a -> a -> a
bitDefault :: (Bits a, Num a) => Int -> a
testBitDefault :: (Bits a, Num a) => a -> Int -> Bool
popCountDefault :: (Bits a, Num a) => a -> Int
toIntegralSized :: (Integral a, Integral b, Bits a, Bits b) => a -> Maybe b
byteSwap16 :: Word16 -> Word16
byteSwap32 :: Word32 -> Word32
byteSwap64 :: Word64 -> Word64
bitReverse8 :: Word8 -> Word8
bitReverse16 :: Word16 -> Word16
bitReverse32 :: Word32 -> Word32
bitReverse64 :: Word64 -> Word64
fill :: (Pointer ptr, LengthUnit len, ByteSource src) => len -> src -> ptr a -> IO (FillResult src)
snd :: (a, b) -> b
curry :: ((a, b) -> c) -> a -> b -> c
void :: Functor f => f a -> f ()
optional :: Alternative f => f a -> f (Maybe a)
lex :: ReadS String
readParen :: Bool -> ReadS a -> ReadS a
alignPtr :: Storable a => Ptr a -> Alignment -> Ptr a
either :: (a -> c) -> (b -> c) -> Either a b -> c
reads :: Read a => ReadS a
read :: Read a => String -> a
oneBits :: FiniteBits a => a
(.^.) :: Bits a => a -> a -> a
(.>>.) :: Bits a => a -> Int -> a
(.<<.) :: Bits a => a -> Int -> a
(!>>.) :: Bits a => a -> Int -> a
(!<<.) :: Bits a => a -> Int -> a
alignment :: Storable a => Proxy a -> Alignment
asProxyTypeOf :: a -> proxy a -> a
mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()
forM_ :: (Foldable t, Monad m) => t a -> (a -> m b) -> m ()
sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()
asum :: (Foldable t, Alternative f) => t (f a) -> f a
msum :: (Foldable t, MonadPlus m) => t (m a) -> m a
lines :: String -> [String]
unlines :: [String] -> String
words :: String -> [String]
unwords :: [String] -> String
userError :: String -> IOError
encode :: (Encodable a, Format fmt) => a -> fmt
write :: EndianStore a => a -> WriteTo
nativeNewline :: Newline
universalNewlineMode :: NewlineMode
nativeNewlineMode :: NewlineMode
noNewlineTranslation :: NewlineMode
ioError :: IOError -> IO a
utf8_bom :: TextEncoding
utf32 :: TextEncoding
utf32be :: TextEncoding
utf32le :: TextEncoding
utf16 :: TextEncoding
utf16be :: TextEncoding
utf16le :: TextEncoding
latin1 :: TextEncoding
char8 :: TextEncoding
memcpy :: (LengthUnit l, Pointer ptrS, Pointer ptrD) => Dest (ptrD dest) -> Src (ptrS src) -> l -> IO ()
hGetChar :: Handle -> IO Char
hGetLine :: Handle -> IO String
hGetContents' :: Handle -> IO String
hPutChar :: Handle -> Char -> IO ()
hPutStr :: Handle -> String -> IO ()
hPutStrLn :: Handle -> String -> IO ()
hPutBufNonBlocking :: Handle -> Ptr a -> Int -> IO Int
hGetBufSome :: Handle -> Ptr a -> Int -> IO Int
hGetBufNonBlocking :: Handle -> Ptr a -> Int -> IO Int
withFile :: FilePath -> IOMode -> (Handle -> IO r) -> IO r
openBinaryFile :: FilePath -> IOMode -> IO Handle
withBinaryFile :: FilePath -> IOMode -> (Handle -> IO r) -> IO r
hFileSize :: Handle -> IO Integer
hSetFileSize :: Handle -> Integer -> IO ()
hIsEOF :: Handle -> IO Bool
isEOF :: IO Bool
hSetBuffering :: Handle -> BufferMode -> IO ()
hSetEncoding :: Handle -> TextEncoding -> IO ()
hGetEncoding :: Handle -> IO (Maybe TextEncoding)
hGetPosn :: Handle -> IO HandlePosn
hSetPosn :: HandlePosn -> IO ()
hTell :: Handle -> IO Integer
hIsOpen :: Handle -> IO Bool
hIsClosed :: Handle -> IO Bool
hIsReadable :: Handle -> IO Bool
hIsWritable :: Handle -> IO Bool
hGetBuffering :: Handle -> IO BufferMode
hIsSeekable :: Handle -> IO Bool
hSetEcho :: Handle -> Bool -> IO ()
hGetEcho :: Handle -> IO Bool
hSetNewlineMode :: Handle -> NewlineMode -> IO ()
hShow :: Handle -> IO String
putChar :: Char -> IO ()
putStr :: String -> IO ()
getChar :: IO Char
getContents :: IO String
getContents' :: IO String
interact :: (String -> String) -> IO ()
readFile :: FilePath -> IO String
appendFile :: FilePath -> String -> IO ()
readLn :: Read a => IO a
readIO :: Read a => String -> IO a
hReady :: Handle -> IO Bool
hPrint :: Show a => Handle -> a -> IO ()
openTempFile :: FilePath -> String -> IO (FilePath, Handle)
openBinaryTempFile :: FilePath -> String -> IO (FilePath, Handle)
openTempFileWithDefaultPermissions :: FilePath -> String -> IO (FilePath, Handle)
openBinaryTempFileWithDefaultPermissions :: FilePath -> String -> IO (FilePath, Handle)
filterM :: Applicative m => (a -> m Bool) -> [a] -> m [a]
(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
mapAndUnzipM :: Applicative m => (a -> m (b, c)) -> [a] -> m ([b], [c])
zipWithM :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c]
zipWithM_ :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m ()
foldM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
foldM_ :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m ()
replicateM :: Applicative m => Int -> m a -> m [a]
replicateM_ :: Applicative m => Int -> m a -> m ()
unless :: Applicative f => Bool -> f () -> f ()
(<$!>) :: Monad m => (a -> b) -> m a -> m b
mfilter :: MonadPlus m => (a -> Bool) -> m a -> m a
runIO :: IO r -> SpecM a r
decode :: (Format fmt, Encodable a) => fmt -> Maybe a
atMost :: (LengthUnit src, LengthUnit dest) => src -> dest
create :: LengthUnit l => l -> (Ptr a -> IO ()) -> IO ByteString
memset :: (LengthUnit l, Pointer ptr) => ptr a -> Word8 -> l -> IO ()
pack :: [Word8] -> ByteString
modifyMaxSuccess :: (Int -> Int) -> SpecWith a -> SpecWith a
modifyMaxDiscardRatio :: (Int -> Int) -> SpecWith a -> SpecWith a
modifyMaxSize :: (Int -> Int) -> SpecWith a -> SpecWith a
modifyMaxShrinks :: (Int -> Int) -> SpecWith a -> SpecWith a
modifyArgs :: (Args -> Args) -> SpecWith a -> SpecWith a
before :: IO a -> SpecWith a -> Spec
before_ :: IO () -> SpecWith a -> SpecWith a
beforeWith :: (b -> IO a) -> SpecWith a -> SpecWith b
beforeAll :: HasCallStack => IO a -> SpecWith a -> Spec
beforeAll_ :: HasCallStack => IO () -> SpecWith a -> SpecWith a
beforeAllWith :: HasCallStack => (b -> IO a) -> SpecWith a -> SpecWith b
after :: ActionWith a -> SpecWith a -> SpecWith a
after_ :: IO () -> SpecWith a -> SpecWith a
around :: (ActionWith a -> IO ()) -> SpecWith a -> Spec
afterAll :: HasCallStack => ActionWith a -> SpecWith a -> SpecWith a
afterAll_ :: HasCallStack => IO () -> SpecWith a -> SpecWith a
around_ :: (IO () -> IO ()) -> SpecWith a -> SpecWith a
aroundWith :: (ActionWith a -> ActionWith b) -> SpecWith a -> SpecWith b
aroundAll :: HasCallStack => (ActionWith a -> IO ()) -> SpecWith a -> Spec
aroundAll_ :: HasCallStack => (IO () -> IO ()) -> SpecWith a -> SpecWith a
aroundAllWith :: HasCallStack => (ActionWith a -> ActionWith b) -> SpecWith a -> SpecWith b
mapSubject :: (b -> a) -> SpecWith a -> SpecWith b
ignoreSubject :: SpecWith () -> SpecWith a
describe :: HasCallStack => String -> SpecWith a -> SpecWith a
context :: HasCallStack => String -> SpecWith a -> SpecWith a
xdescribe :: HasCallStack => String -> SpecWith a -> SpecWith a
xcontext :: HasCallStack => String -> SpecWith a -> SpecWith a
it :: (HasCallStack, Example a) => String -> a -> SpecWith (Arg a)
specify :: (HasCallStack, Example a) => String -> a -> SpecWith (Arg a)
xit :: (HasCallStack, Example a) => String -> a -> SpecWith (Arg a)
xspecify :: (HasCallStack, Example a) => String -> a -> SpecWith (Arg a)
focus :: SpecWith a -> SpecWith a
fit :: (HasCallStack, Example a) => String -> a -> SpecWith (Arg a)
fspecify :: (HasCallStack, Example a) => String -> a -> SpecWith (Arg a)
fdescribe :: HasCallStack => String -> SpecWith a -> SpecWith a
fcontext :: HasCallStack => String -> SpecWith a -> SpecWith a
parallel :: SpecWith a -> SpecWith a
sequential :: SpecWith a -> SpecWith a
pending :: HasCallStack => Expectation
pendingWith :: HasCallStack => String -> Expectation
example :: Expectation -> Expectation
prop :: (HasCallStack, Testable prop) => String -> prop -> Spec
xprop :: (HasCallStack, Testable prop) => String -> prop -> Spec
fprop :: (HasCallStack, Testable prop) => String -> prop -> Spec
expectationFailure :: HasCallStack => String -> Expectation
shouldBe :: (HasCallStack, Show a, Eq a) => a -> a -> Expectation
shouldSatisfy :: (HasCallStack, Show a) => a -> (a -> Bool) -> Expectation
shouldStartWith :: (HasCallStack, Show a, Eq a) => [a] -> [a] -> Expectation
shouldEndWith :: (HasCallStack, Show a, Eq a) => [a] -> [a] -> Expectation
shouldContain :: (HasCallStack, Show a, Eq a) => [a] -> [a] -> Expectation
shouldMatchList :: (HasCallStack, Show a, Eq a) => [a] -> [a] -> Expectation
shouldReturn :: (HasCallStack, Show a, Eq a) => IO a -> a -> Expectation
shouldNotBe :: (HasCallStack, Show a, Eq a) => a -> a -> Expectation
shouldNotSatisfy :: (HasCallStack, Show a) => a -> (a -> Bool) -> Expectation
shouldNotContain :: (HasCallStack, Show a, Eq a) => [a] -> [a] -> Expectation
shouldNotReturn :: (HasCallStack, Show a, Eq a) => IO a -> a -> Expectation
shouldThrow :: (HasCallStack, Exception e) => IO a -> Selector e -> Expectation
anyException :: Selector SomeException
anyErrorCall :: Selector ErrorCall
errorCall :: String -> Selector ErrorCall
anyIOException :: Selector IOException
anyArithException :: Selector ArithException
movePtr :: LengthUnit l => Ptr a -> l -> Ptr a
translate :: (Format fmt1, Format fmt2) => fmt1 -> fmt2
unsafeFromList :: forall a (dim :: Nat). (Unbox a, Dimension dim) => [a] -> Tuple dim a
processChunks :: (Pointer ptr, MonadIO m, LengthUnit chunkSize, ByteSource src) => m a -> (BYTES Int -> m b) -> src -> ptr something -> chunkSize -> m b
withFillResult :: (a -> b) -> (BYTES Int -> b) -> FillResult a -> b
l1Cache :: BYTES Int
unsafeDecode :: (Format fmt, Encodable a) => fmt -> a
fromBase16 :: Encodable a => String -> a
showBase16 :: Encodable a => a -> String
copyCell :: Storable a => Dest (MemoryCell a) -> Src (MemoryCell a) -> IO ()
memTransfer :: (ReadAccessible src, WriteAccessible dest) => Dest dest -> Src src -> IO ()
modifyMem :: (Initialisable mem a, Extractable mem b) => (b -> a) -> mem -> IO ()
pointerAlloc :: LengthUnit l => l -> Alloc (Ptr Word8)
unsafeGetCellPointer :: Storable a => MemoryCell a -> Ptr a
withCellPointer :: Storable a => (Ptr a -> IO b) -> MemoryCell a -> IO b
withMemory :: Memory mem => (mem -> IO a) -> IO a
withMemoryPtr :: Memory m => (BYTES Int -> Ptr Word8 -> IO a) -> m -> IO a
withSecureMemory :: Memory mem => (mem -> IO a) -> IO a
blocksOf :: Int -> Proxy p -> BlockCount p
consume :: EndianStore a => (a -> IO b) -> ReadFrom
consumeParse :: Parser a -> (a -> IO b) -> ReadFrom
consumeStorable :: Storable a => (a -> IO b) -> ReadFrom
glueWrites :: LengthUnit n => Word8 -> n -> WriteTo -> WriteTo -> WriteTo
padWrite :: LengthUnit n => Word8 -> n -> WriteTo -> WriteTo
prependWrite :: LengthUnit n => Word8 -> n -> WriteTo -> WriteTo
skip :: forall l (t :: Mode). LengthUnit l => l -> Transfer t
writeBytes :: LengthUnit n => Word8 -> n -> WriteTo
writeEncodable :: Encodable a => a -> WriteTo
writeStorable :: Storable a => a -> WriteTo
writeStorableVector :: (Storable a, Vector v a) => v a -> WriteTo
writeVector :: (EndianStore a, Vector v a) => v a -> WriteTo
transferSize :: forall (t :: Mode). Transfer t -> BYTES Int
writeByteString :: ByteString -> WriteTo
destination :: a -> Dest a
source :: a -> Src a
bigEndian :: w -> BE w
copyFromBytes :: EndianStore w => Dest (Ptr w) -> Src (Ptr Word8) -> Int -> IO ()
copyToBytes :: EndianStore w => Dest (Ptr Word8) -> Src (Ptr w) -> Int -> IO ()
littleEndian :: w -> LE w
loadFrom :: (EndianStore w, LengthUnit offset) => Ptr w -> offset -> IO w
loadFromIndex :: EndianStore w => Ptr w -> Int -> IO w
storeAt :: (EndianStore w, LengthUnit offset) => Ptr w -> offset -> w -> IO ()
storeAtIndex :: EndianStore w => Ptr w -> Int -> w -> IO ()
alignedSizeOf :: Storable a => Proxy a -> BYTES Int
allocaBuffer :: (LengthUnit l, Pointer ptr) => l -> (ptr something -> IO b) -> IO b
allocaSecure :: (LengthUnit l, Pointer ptr) => l -> (ptr a -> IO b) -> IO b
atLeast :: (LengthUnit src, LengthUnit dest) => src -> dest
atLeastAligned :: LengthUnit l => l -> Alignment -> BYTES Int
hFillBuf :: (LengthUnit bufSize, Pointer ptr) => Handle -> ptr a -> bufSize -> IO (BYTES Int)
nextAlignedPtr :: forall a (n :: Nat). (Storable a, KnownNat n) => Ptr a -> AlignedPtr n a
nextLocation :: Storable a => Ptr a -> Ptr a
peekAligned :: Storable a => Ptr a -> IO a
pokeAligned :: Storable a => Ptr a -> a -> IO ()
ptrAlignment :: forall (n :: Nat) a. KnownNat n => Proxy (AlignedPtr n a) -> Alignment
unsafeWithPointer :: Pointer ptr => (Ptr a -> b) -> ptr a -> b
unsafeWithPointerCast :: Pointer ptr => (Ptr a -> b) -> ptr something -> b
wipeMemory :: (LengthUnit l, Pointer ptr) => ptr a -> l -> IO ()
diagonal :: forall a (dim :: Nat). (Unbox a, Dimension dim) => a -> Tuple dim a
dimension :: forall (dim :: Nat) a. Dimension dim => Tuple dim a -> Int
dimension' :: forall (dim :: Nat) a. Dimension dim => Proxy (Tuple dim a) -> Int
generateIO :: forall (dim :: Nat) a. (Dimension dim, Unbox a) => IO a -> IO (Tuple dim a)
initial :: forall a (dim0 :: Nat) (dim1 :: Nat). (Unbox a, Dimension dim0) => Tuple dim1 a -> Tuple dim0 a
repeatM :: forall m a (dim :: Nat). (Monad m, Unbox a, Dimension dim) => m a -> m (Tuple dim a)
unsafeFromVector :: forall a (dim :: Nat). Vector a -> Tuple dim a
unsafeToVector :: forall (dim :: Nat) a. Tuple dim a -> Vector a
createFrom :: LengthUnit l => l -> Ptr a -> IO ByteString
unsafeCopyToPointer :: Pointer ptr => ByteString -> ptr a -> IO ()
unsafeNCopyToPointer :: LengthUnit n => n -> ByteString -> Ptr a -> IO ()
withByteString :: ByteString -> (Ptr something -> IO a) -> IO a
blake2Pad :: Primitive prim => Proxy prim -> BYTES Int -> WriteTo
counterCellPtr :: ChaCha20Mem -> Ptr WORD
ivCellPtr :: ChaCha20Mem -> Ptr (Nounce ChaCha20)
keyCellPtr :: ChaCha20Mem -> Ptr (Key ChaCha20)
process256Last :: forall (n :: Nat). KnownNat n => Compressor256 n -> AlignedBlockPtr n Sha256 -> BYTES Int -> Sha256Mem -> IO ()
process512Last :: forall (n :: Nat). KnownNat n => Compressor512 n -> AlignedBlockPtr n Sha512 -> BYTES Int -> Sha512Mem -> IO ()

Documentation

data Result #

Result represents the test result

Constructors

Success	A successful test run
Fields numTests :: Int Number of tests performed numDiscarded :: Int Number of tests skipped labels :: !(Map [String] Int) The number of test cases having each combination of labels (see `label`) classes :: !(Map String Int) The number of test cases having each class (see `classify`) tables :: !(Map String (Map String Int)) Data collected by `tabulate` output :: String Printed output
GaveUp	Given up
Fields numTests :: Int Number of tests performed numDiscarded :: Int Number of tests skipped labels :: !(Map [String] Int) The number of test cases having each combination of labels (see `label`) classes :: !(Map String Int) The number of test cases having each class (see `classify`) tables :: !(Map String (Map String Int)) Data collected by `tabulate` output :: String Printed output
Failure	A failed test run
Fields numTests :: Int Number of tests performed numDiscarded :: Int Number of tests skipped numShrinks :: Int Number of successful shrinking steps performed numShrinkTries :: Int Number of unsuccessful shrinking steps performed numShrinkFinal :: Int Number of unsuccessful shrinking steps performed since last successful shrink usedSeed :: QCGen What seed was used usedSize :: Int What was the test size reason :: String Why did the property fail theException :: Maybe AnException The exception the property threw, if any output :: String Printed output failingTestCase :: [String] The test case which provoked the failure failingLabels :: [String] The test case's labels (see `label`) failingClasses :: Set String The test case's classes (see `classify`) witnesses :: [Witness] The existentially quantified witnesses provided by `witness`
NoExpectedFailure	A property that should have failed did not
Fields numTests :: Int Number of tests performed numDiscarded :: Int Number of tests skipped labels :: !(Map [String] Int) The number of test cases having each combination of labels (see `label`) classes :: !(Map String Int) The number of test cases having each class (see `classify`) tables :: !(Map String (Map String Int)) Data collected by `tabulate` output :: String Printed output

Instances

Instances details

Show Result
Instance details Defined in Test.QuickCheck.Test Methods showsPrec :: Int -> Result -> ShowS # show :: Result -> String # showList :: [Result] -> ShowS #

class Testable prop where #

The class of properties, i.e., types which QuickCheck knows how to test. Typically a property will be a function returning Bool or Property.

Minimal complete definition

property

Methods

property :: prop -> Property #

Convert the thing to a property.

propertyForAllShrinkShow :: Gen a -> (a -> [a]) -> (a -> [String]) -> (a -> prop) -> Property #

Optional; used internally in order to improve shrinking. Tests a property but also quantifies over an extra value (with a custom shrink and show function). The Testable instance for functions defines propertyForAllShrinkShow in a way that improves shrinking.

Instances

Instances details

Testable Discard
Instance details Defined in Test.QuickCheck.Property Methods property :: Discard -> Property # propertyForAllShrinkShow :: Gen a -> (a -> [a]) -> (a -> [String]) -> (a -> Discard) -> Property #
Testable Prop
Instance details Defined in Test.QuickCheck.Property Methods property :: Prop -> Property # propertyForAllShrinkShow :: Gen a -> (a -> [a]) -> (a -> [String]) -> (a -> Prop) -> Property #
Testable Property
Instance details Defined in Test.QuickCheck.Property Methods property :: Property -> Property # propertyForAllShrinkShow :: Gen a -> (a -> [a]) -> (a -> [String]) -> (a -> Property) -> Property #
Testable Result
Instance details Defined in Test.QuickCheck.Property Methods property :: Result -> Property # propertyForAllShrinkShow :: Gen a -> (a -> [a]) -> (a -> [String]) -> (a -> Result) -> Property #
Testable ()
Instance details Defined in Test.QuickCheck.Property Methods property :: () -> Property # propertyForAllShrinkShow :: Gen a -> (a -> [a]) -> (a -> [String]) -> (a -> ()) -> Property #
Testable Bool
Instance details Defined in Test.QuickCheck.Property Methods property :: Bool -> Property # propertyForAllShrinkShow :: Gen a -> (a -> [a]) -> (a -> [String]) -> (a -> Bool) -> Property #
Testable prop => Testable (Gen prop)
Instance details Defined in Test.QuickCheck.Property Methods property :: Gen prop -> Property # propertyForAllShrinkShow :: Gen a -> (a -> [a]) -> (a -> [String]) -> (a -> Gen prop) -> Property #
Testable prop => Testable (Maybe prop)
Instance details Defined in Test.QuickCheck.Property Methods property :: Maybe prop -> Property # propertyForAllShrinkShow :: Gen a -> (a -> [a]) -> (a -> [String]) -> (a -> Maybe prop) -> Property #
(Arbitrary a, Show a, Testable prop) => Testable (a -> prop)
Instance details Defined in Test.QuickCheck.Property Methods property :: (a -> prop) -> Property # propertyForAllShrinkShow :: Gen a0 -> (a0 -> [a0]) -> (a0 -> [String]) -> (a0 -> a -> prop) -> Property #

type ShowS = String -> String #

The shows functions return a function that prepends the output String to an existing String. This allows constant-time concatenation of results using function composition.

type String = [Char] #

A String is a list of characters. String constants in Haskell are values of type String.

See Data.List for operations on lists.

data FUN #

The builtin function type, written in infix form as a % m -> b. Values of this type are functions taking inputs of type a and producing outputs of type b. The multiplicity of the input is m.

Note that FUN m a b permits representation polymorphism in both a and b, so that types like Int# -> Int# can still be well-kinded.

Instances

Instances details

IsString WriteTo
Instance details Defined in Raaz.Core.Transfer.Unsafe Methods fromString :: String -> WriteTo #
Encodable WriteTo
Instance details Defined in Raaz.Core.Transfer.Unsafe Methods toByteString :: WriteTo -> ByteString # fromByteString :: ByteString -> Maybe WriteTo # unsafeFromByteString :: ByteString -> WriteTo #
Distributive (BYTES Int) (TransferAction t)
Instance details Defined in Raaz.Core.Transfer.Unsafe
LAction (BYTES Int) (TransferAction t)
Instance details Defined in Raaz.Core.Transfer.Unsafe Methods (<.>) :: BYTES Int -> TransferAction t -> TransferAction t
(CoArbitrary a, Arbitrary b) => Arbitrary (a -> b)
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (a -> b) # shrink :: (a -> b) -> [a -> b] #
(Arbitrary a, CoArbitrary b) => CoArbitrary (a -> b)
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: (a -> b) -> Gen b0 -> Gen b0 #
(Arbitrary a, Show a, Testable prop) => Testable (a -> prop)
Instance details Defined in Test.QuickCheck.Property Methods property :: (a -> prop) -> Property # propertyForAllShrinkShow :: Gen a0 -> (a0 -> [a0]) -> (a0 -> [String]) -> (a0 -> a -> prop) -> Property #
Monoid b => Monoid (a -> b)	Since: base-2.1
Instance details Defined in GHC.Base Methods mempty :: a -> b # mappend :: (a -> b) -> (a -> b) -> a -> b # mconcat :: [a -> b] -> a -> b #
Semigroup b => Semigroup (a -> b)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (<>) :: (a -> b) -> (a -> b) -> a -> b # sconcat :: NonEmpty (a -> b) -> a -> b # stimes :: Integral b0 => b0 -> (a -> b) -> a -> b #
NFData (a -> b)	This instance is for convenience and consistency with `seq`. This assumes that WHNF is equivalent to NF for functions. Since: deepseq-1.3.0.0
Instance details Defined in Control.DeepSeq Methods rnf :: (a -> b) -> () #
Example (a -> Result)
Instance details Defined in Test.Hspec.Core.Example Associated Types type Arg (a -> Result) # Methods evaluateExample :: (a -> Result) -> Params -> (ActionWith (Arg (a -> Result)) -> IO ()) -> ProgressCallback -> IO Result #
Example (a -> Expectation)
Instance details Defined in Test.Hspec.Core.Example Associated Types type Arg (a -> Expectation) # Methods evaluateExample :: (a -> Expectation) -> Params -> (ActionWith (Arg (a -> Expectation)) -> IO ()) -> ProgressCallback -> IO Result #
Example (a -> Bool)
Instance details Defined in Test.Hspec.Core.Example Associated Types type Arg (a -> Bool) # Methods evaluateExample :: (a -> Bool) -> Params -> (ActionWith (Arg (a -> Bool)) -> IO ()) -> ProgressCallback -> IO Result #
CoArbitrary a => Arbitrary1 ((->) a)
Instance details Defined in Test.QuickCheck.Arbitrary Methods liftArbitrary :: Gen a0 -> Gen (a -> a0) # liftShrink :: (a0 -> [a0]) -> (a -> a0) -> [a -> a0] #
Applicative ((->) r)	Since: base-2.1
Instance details Defined in GHC.Base Methods pure :: a -> r -> a # (<>) :: (r -> (a -> b)) -> (r -> a) -> r -> b # liftA2 :: (a -> b -> c) -> (r -> a) -> (r -> b) -> r -> c # (>) :: (r -> a) -> (r -> b) -> r -> b # (<*) :: (r -> a) -> (r -> b) -> r -> a #
Functor ((->) r)	Since: base-2.1
Instance details Defined in GHC.Base Methods fmap :: (a -> b) -> (r -> a) -> r -> b # (<$) :: a -> (r -> b) -> r -> a #
Monad ((->) r)	Since: base-2.1
Instance details Defined in GHC.Base Methods (>>=) :: (r -> a) -> (a -> r -> b) -> r -> b # (>>) :: (r -> a) -> (r -> b) -> r -> b # return :: a -> r -> a #
type Arg (a -> Property)
Instance details Defined in Test.Hspec.Core.QuickCheck type Arg (a -> Property) = a
type Arg (a -> Result)
Instance details Defined in Test.Hspec.Core.Example type Arg (a -> Result) = a
type Arg (a -> Expectation)
Instance details Defined in Test.Hspec.Core.Example type Arg (a -> Expectation) = a
type Arg (a -> Bool)
Instance details Defined in Test.Hspec.Core.Example type Arg (a -> Bool) = a

data Bool #

Constructors

False
True

Instances

Instances details

Arbitrary Bool
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen Bool # shrink :: Bool -> [Bool] #
CoArbitrary Bool
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Bool -> Gen b -> Gen b #
Function Bool
Instance details Defined in Test.QuickCheck.Function Methods function :: (Bool -> b) -> Bool :-> b #
Testable Bool
Instance details Defined in Test.QuickCheck.Property Methods property :: Bool -> Property # propertyForAllShrinkShow :: Gen a -> (a -> [a]) -> (a -> [String]) -> (a -> Bool) -> Property #
Storable Bool	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Bool -> Int # alignment :: Bool -> Int # peekElemOff :: Ptr Bool -> Int -> IO Bool # pokeElemOff :: Ptr Bool -> Int -> Bool -> IO () # peekByteOff :: Ptr b -> Int -> IO Bool # pokeByteOff :: Ptr b -> Int -> Bool -> IO () # peek :: Ptr Bool -> IO Bool # poke :: Ptr Bool -> Bool -> IO () #
Bits Bool	Interpret `Bool` as 1-bit bit-field Since: base-4.7.0.0
Instance details Defined in GHC.Bits Methods (.&.) :: Bool -> Bool -> Bool # (.\|.) :: Bool -> Bool -> Bool # xor :: Bool -> Bool -> Bool # complement :: Bool -> Bool # shift :: Bool -> Int -> Bool # rotate :: Bool -> Int -> Bool # zeroBits :: Bool # bit :: Int -> Bool # setBit :: Bool -> Int -> Bool # clearBit :: Bool -> Int -> Bool # complementBit :: Bool -> Int -> Bool # testBit :: Bool -> Int -> Bool # bitSizeMaybe :: Bool -> Maybe Int # bitSize :: Bool -> Int # isSigned :: Bool -> Bool # shiftL :: Bool -> Int -> Bool # unsafeShiftL :: Bool -> Int -> Bool # shiftR :: Bool -> Int -> Bool # unsafeShiftR :: Bool -> Int -> Bool # rotateL :: Bool -> Int -> Bool # rotateR :: Bool -> Int -> Bool # popCount :: Bool -> Int #
FiniteBits Bool	Since: base-4.7.0.0
Instance details Defined in GHC.Bits Methods finiteBitSize :: Bool -> Int # countLeadingZeros :: Bool -> Int # countTrailingZeros :: Bool -> Int #
Bounded Bool	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Bool # maxBound :: Bool #
Enum Bool	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Bool -> Bool # pred :: Bool -> Bool # toEnum :: Int -> Bool # fromEnum :: Bool -> Int # enumFrom :: Bool -> [Bool] # enumFromThen :: Bool -> Bool -> [Bool] # enumFromTo :: Bool -> Bool -> [Bool] # enumFromThenTo :: Bool -> Bool -> Bool -> [Bool] #
Generic Bool
Instance details Defined in GHC.Generics Associated Types type Rep Bool :: Type -> Type # Methods from :: Bool -> Rep Bool x # to :: Rep Bool x -> Bool #
SingKind Bool	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type DemoteRep Bool Methods fromSing :: forall (a :: Bool). Sing a -> DemoteRep Bool
Read Bool	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Bool # readList :: ReadS [Bool] # readPrec :: ReadPrec Bool # readListPrec :: ReadPrec [Bool] #
Show Bool	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Bool -> ShowS # show :: Bool -> String # showList :: [Bool] -> ShowS #
NFData Bool
Instance details Defined in Control.DeepSeq Methods rnf :: Bool -> () #
Eq Bool
Instance details Defined in GHC.Classes Methods (==) :: Bool -> Bool -> Bool # (/=) :: Bool -> Bool -> Bool #
Ord Bool
Instance details Defined in GHC.Classes Methods compare :: Bool -> Bool -> Ordering # (<) :: Bool -> Bool -> Bool # (<=) :: Bool -> Bool -> Bool # (>) :: Bool -> Bool -> Bool # (>=) :: Bool -> Bool -> Bool # max :: Bool -> Bool -> Bool # min :: Bool -> Bool -> Bool #
Example Bool
Instance details Defined in Test.Hspec.Core.Example Associated Types type Arg Bool # Methods evaluateExample :: Bool -> Params -> (ActionWith (Arg Bool) -> IO ()) -> ProgressCallback -> IO Result #
Random Bool
Instance details Defined in System.Random Methods randomR :: RandomGen g => (Bool, Bool) -> g -> (Bool, g) # random :: RandomGen g => g -> (Bool, g) # randomRs :: RandomGen g => (Bool, Bool) -> g -> [Bool] # randoms :: RandomGen g => g -> [Bool] #
Uniform Bool
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m Bool #
UniformRange Bool
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (Bool, Bool) -> g -> m Bool #
Unbox Bool
Instance details Defined in Data.Vector.Unboxed.Base
SingI 'False	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods sing :: Sing 'False
SingI 'True	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods sing :: Sing 'True
Lift Bool
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Bool -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Bool -> Code m Bool #
Vector Vector Bool
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s Bool -> ST s (Vector Bool) # basicUnsafeThaw :: Vector Bool -> ST s (Mutable Vector s Bool) # basicLength :: Vector Bool -> Int # basicUnsafeSlice :: Int -> Int -> Vector Bool -> Vector Bool # basicUnsafeIndexM :: Vector Bool -> Int -> Box Bool # basicUnsafeCopy :: Mutable Vector s Bool -> Vector Bool -> ST s () # elemseq :: Vector Bool -> Bool -> b -> b #
MVector MVector Bool
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Bool -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Bool -> MVector s Bool # basicOverlaps :: MVector s Bool -> MVector s Bool -> Bool # basicUnsafeNew :: Int -> ST s (MVector s Bool) # basicInitialize :: MVector s Bool -> ST s () # basicUnsafeReplicate :: Int -> Bool -> ST s (MVector s Bool) # basicUnsafeRead :: MVector s Bool -> Int -> ST s Bool # basicUnsafeWrite :: MVector s Bool -> Int -> Bool -> ST s () # basicClear :: MVector s Bool -> ST s () # basicSet :: MVector s Bool -> Bool -> ST s () # basicUnsafeCopy :: MVector s Bool -> MVector s Bool -> ST s () # basicUnsafeMove :: MVector s Bool -> MVector s Bool -> ST s () # basicUnsafeGrow :: MVector s Bool -> Int -> ST s (MVector s Bool) #
Example (a -> Bool)
Instance details Defined in Test.Hspec.Core.Example Associated Types type Arg (a -> Bool) # Methods evaluateExample :: (a -> Bool) -> Params -> (ActionWith (Arg (a -> Bool)) -> IO ()) -> ProgressCallback -> IO Result #
type DemoteRep Bool
Instance details Defined in GHC.Generics type DemoteRep Bool = Bool
type Rep Bool	Since: base-4.6.0.0
Instance details Defined in GHC.Generics type Rep Bool = D1 ('MetaData "Bool" "GHC.Types" "ghc-prim" 'False) (C1 ('MetaCons "False" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "True" 'PrefixI 'False) (U1 :: Type -> Type))
data Sing (a :: Bool)
Instance details Defined in GHC.Generics data Sing (a :: Bool) where STrue :: Sing 'True SFalse :: Sing 'False
type Arg Bool
Instance details Defined in Test.Hspec.Core.Example type Arg Bool = ()
newtype Vector Bool
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Bool = V_Bool (Vector Word8)
newtype MVector s Bool
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Bool = MV_Bool (MVector s Word8)
type Arg (a -> Bool)
Instance details Defined in Test.Hspec.Core.Example type Arg (a -> Bool) = a

data Char #

The character type Char is an enumeration whose values represent Unicode (or equivalently ISO/IEC 10646) code points (i.e. 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).

Instances

Instances details

Arbitrary Char
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen Char # shrink :: Char -> [Char] #
CoArbitrary Char
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Char -> Gen b -> Gen b #
Function Char
Instance details Defined in Test.QuickCheck.Function Methods function :: (Char -> b) -> Char :-> b #
Storable Char	Since: base-2.1
Instance details Defined in Foreign.Storable 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 () #
Bounded Char	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Char # maxBound :: Char #
Enum Char	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Char -> Char # pred :: Char -> Char # toEnum :: Int -> Char # fromEnum :: Char -> Int # enumFrom :: Char -> [Char] # enumFromThen :: Char -> Char -> [Char] # enumFromTo :: Char -> Char -> [Char] # enumFromThenTo :: Char -> Char -> Char -> [Char] #
Read Char	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Char # readList :: ReadS [Char] # readPrec :: ReadPrec Char # readListPrec :: ReadPrec [Char] #
Show Char	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Char -> ShowS # show :: Char -> String # showList :: [Char] -> ShowS #
NFData Char
Instance details Defined in Control.DeepSeq Methods rnf :: Char -> () #
Eq Char
Instance details Defined in GHC.Classes Methods (==) :: Char -> Char -> Bool # (/=) :: Char -> Char -> Bool #
Ord Char
Instance details Defined in GHC.Classes Methods compare :: Char -> Char -> Ordering # (<) :: Char -> Char -> Bool # (<=) :: Char -> Char -> Bool # (>) :: Char -> Char -> Bool # (>=) :: Char -> Char -> Bool # max :: Char -> Char -> Char # min :: Char -> Char -> Char #
Random Char
Instance details Defined in System.Random Methods randomR :: RandomGen g => (Char, Char) -> g -> (Char, g) # random :: RandomGen g => g -> (Char, g) # randomRs :: RandomGen g => (Char, Char) -> g -> [Char] # randoms :: RandomGen g => g -> [Char] #
Uniform Char
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m Char #
UniformRange Char
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (Char, Char) -> g -> m Char #
Unbox Char
Instance details Defined in Data.Vector.Unboxed.Base
Lift Char
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Char -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Char -> Code m Char #
Vector Vector Char
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s Char -> ST s (Vector Char) # basicUnsafeThaw :: Vector Char -> ST s (Mutable Vector s Char) # basicLength :: Vector Char -> Int # basicUnsafeSlice :: Int -> Int -> Vector Char -> Vector Char # basicUnsafeIndexM :: Vector Char -> Int -> Box Char # basicUnsafeCopy :: Mutable Vector s Char -> Vector Char -> ST s () # elemseq :: Vector Char -> Char -> b -> b #
MVector MVector Char
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Char -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Char -> MVector s Char # basicOverlaps :: MVector s Char -> MVector s Char -> Bool # basicUnsafeNew :: Int -> ST s (MVector s Char) # basicInitialize :: MVector s Char -> ST s () # basicUnsafeReplicate :: Int -> Char -> ST s (MVector s Char) # basicUnsafeRead :: MVector s Char -> Int -> ST s Char # basicUnsafeWrite :: MVector s Char -> Int -> Char -> ST s () # basicClear :: MVector s Char -> ST s () # basicSet :: MVector s Char -> Char -> ST s () # basicUnsafeCopy :: MVector s Char -> MVector s Char -> ST s () # basicUnsafeMove :: MVector s Char -> MVector s Char -> ST s () # basicUnsafeGrow :: MVector s Char -> Int -> ST s (MVector s Char) #
Generic1 (URec Char :: k -> Type)
Instance details Defined in GHC.Generics Associated Types type Rep1 (URec Char) :: k -> Type # Methods from1 :: forall (a :: k0). URec Char a -> Rep1 (URec Char) a # to1 :: forall (a :: k0). Rep1 (URec Char) a -> URec Char a #
Foldable (UChar :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UChar m -> m # foldMap :: Monoid m => (a -> m) -> UChar a -> m # foldMap' :: Monoid m => (a -> m) -> UChar a -> m # foldr :: (a -> b -> b) -> b -> UChar a -> b # foldr' :: (a -> b -> b) -> b -> UChar a -> b # foldl :: (b -> a -> b) -> b -> UChar a -> b # foldl' :: (b -> a -> b) -> b -> UChar a -> b # foldr1 :: (a -> a -> a) -> UChar a -> a # foldl1 :: (a -> a -> a) -> UChar a -> a # toList :: UChar a -> [a] # null :: UChar a -> Bool # length :: UChar a -> Int # elem :: Eq a => a -> UChar a -> Bool # maximum :: Ord a => UChar a -> a # minimum :: Ord a => UChar a -> a # sum :: Num a => UChar a -> a # product :: Num a => UChar a -> a #
Traversable (UChar :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UChar a -> f (UChar b) # sequenceA :: Applicative f => UChar (f a) -> f (UChar a) # mapM :: Monad m => (a -> m b) -> UChar a -> m (UChar b) # sequence :: Monad m => UChar (m a) -> m (UChar a) #
Functor (URec Char :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec Char a -> URec Char b # (<$) :: a -> URec Char b -> URec Char a #
Generic (URec Char p)
Instance details Defined in GHC.Generics Associated Types type Rep (URec Char p) :: Type -> Type # Methods from :: URec Char p -> Rep (URec Char p) x # to :: Rep (URec Char p) x -> URec Char p #
Show (URec Char p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Char p -> ShowS # show :: URec Char p -> String # showList :: [URec Char p] -> ShowS #
Eq (URec Char p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: URec Char p -> URec Char p -> Bool # (/=) :: URec Char p -> URec Char p -> Bool #
Ord (URec Char p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: URec Char p -> URec Char p -> Ordering # (<) :: URec Char p -> URec Char p -> Bool # (<=) :: URec Char p -> URec Char p -> Bool # (>) :: URec Char p -> URec Char p -> Bool # (>=) :: URec Char p -> URec Char p -> Bool # max :: URec Char p -> URec Char p -> URec Char p # min :: URec Char p -> URec Char p -> URec Char p #
newtype Vector Char
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Char = V_Char (Vector Char)
data URec Char (p :: k)	Used for marking occurrences of `Char#` Since: base-4.9.0.0
Instance details Defined in GHC.Generics data URec Char (p :: k) = UChar { uChar# :: Char# }
newtype MVector s Char
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Char = MV_Char (MVector s Char)
type Rep1 (URec Char :: k -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep1 (URec Char :: k -> Type) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UChar" 'PrefixI 'True) (S1 ('MetaSel ('Just "uChar#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UChar :: k -> Type)))
type Rep (URec Char p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep (URec Char p) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UChar" 'PrefixI 'True) (S1 ('MetaSel ('Just "uChar#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UChar :: Type -> Type)))

data Double #

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

Instances

Instances details

Arbitrary Double
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen Double # shrink :: Double -> [Double] #
CoArbitrary Double
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Double -> Gen b -> Gen b #
Function Double
Instance details Defined in Test.QuickCheck.Function Methods function :: (Double -> b) -> Double :-> b #
Storable Double	Since: base-2.1
Instance details Defined in Foreign.Storable Methods sizeOf :: Double -> Int # alignment :: Double -> Int # peekElemOff :: Ptr Double -> Int -> IO Double # pokeElemOff :: Ptr Double -> Int -> Double -> IO () # peekByteOff :: Ptr b -> Int -> IO Double # pokeByteOff :: Ptr b -> Int -> Double -> IO () # peek :: Ptr Double -> IO Double # poke :: Ptr Double -> Double -> IO () #
Floating Double	Since: base-2.1
Instance details Defined in GHC.Float Methods pi :: Double # exp :: Double -> Double # log :: Double -> Double # sqrt :: Double -> Double # (**) :: Double -> Double -> Double # logBase :: Double -> Double -> Double # sin :: Double -> Double # cos :: Double -> Double # tan :: Double -> Double # asin :: Double -> Double # acos :: Double -> Double # atan :: Double -> Double # sinh :: Double -> Double # cosh :: Double -> Double # tanh :: Double -> Double # asinh :: Double -> Double # acosh :: Double -> Double # atanh :: Double -> Double # log1p :: Double -> Double # expm1 :: Double -> Double # log1pexp :: Double -> Double # log1mexp :: Double -> Double #
RealFloat Double	Since: base-2.1
Instance details Defined in GHC.Float Methods floatRadix :: Double -> Integer # floatDigits :: Double -> Int # floatRange :: Double -> (Int, Int) # decodeFloat :: Double -> (Integer, Int) # encodeFloat :: Integer -> Int -> Double # exponent :: Double -> Int # significand :: Double -> Double # scaleFloat :: Int -> Double -> Double # isNaN :: Double -> Bool # isInfinite :: Double -> Bool # isDenormalized :: Double -> Bool # isNegativeZero :: Double -> Bool # isIEEE :: Double -> Bool # atan2 :: Double -> Double -> Double #
Read Double	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Double # readList :: ReadS [Double] # readPrec :: ReadPrec Double # readListPrec :: ReadPrec [Double] #
NFData Double
Instance details Defined in Control.DeepSeq Methods rnf :: Double -> () #
Eq Double	Note that due to the presence of `NaN`, `Double`'s `Eq` instance does not satisfy reflexivity. `>>>` `0/0 == (0/0 :: Double)`False Also note that `Double`'s `Eq` instance does not satisfy substitutivity: `>>>` `0 == (-0 :: Double)`True `>>>` `recip 0 == recip (-0 :: Double)`False
Instance details Defined in GHC.Classes Methods (==) :: Double -> Double -> Bool # (/=) :: Double -> Double -> Bool #
Ord Double	Note that due to the presence of `NaN`, `Double`'s `Ord` instance does not satisfy reflexivity. `>>>` `0/0 <= (0/0 :: Double)`False Also note that, due to the same, `Ord`'s operator interactions are not respected by `Double`'s instance: `>>>` `(0/0 :: Double) > 1`False `>>>` `compare (0/0 :: Double) 1`GT
Instance details Defined in GHC.Classes Methods compare :: Double -> Double -> Ordering # (<) :: Double -> Double -> Bool # (<=) :: Double -> Double -> Bool # (>) :: Double -> Double -> Bool # (>=) :: Double -> Double -> Bool # max :: Double -> Double -> Double # min :: Double -> Double -> Double #
Random Double	Note - `random` produces values in the closed range `[0,1]`.
Instance details Defined in System.Random Methods randomR :: RandomGen g => (Double, Double) -> g -> (Double, g) # random :: RandomGen g => g -> (Double, g) # randomRs :: RandomGen g => (Double, Double) -> g -> [Double] # randoms :: RandomGen g => g -> [Double] #
UniformRange Double	See Floating point number caveats.
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (Double, Double) -> g -> m Double #
Unbox Double
Instance details Defined in Data.Vector.Unboxed.Base
Lift Double
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Double -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Double -> Code m Double #
Vector Vector Double
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s Double -> ST s (Vector Double) # basicUnsafeThaw :: Vector Double -> ST s (Mutable Vector s Double) # basicLength :: Vector Double -> Int # basicUnsafeSlice :: Int -> Int -> Vector Double -> Vector Double # basicUnsafeIndexM :: Vector Double -> Int -> Box Double # basicUnsafeCopy :: Mutable Vector s Double -> Vector Double -> ST s () # elemseq :: Vector Double -> Double -> b -> b #
MVector MVector Double
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Double -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Double -> MVector s Double # basicOverlaps :: MVector s Double -> MVector s Double -> Bool # basicUnsafeNew :: Int -> ST s (MVector s Double) # basicInitialize :: MVector s Double -> ST s () # basicUnsafeReplicate :: Int -> Double -> ST s (MVector s Double) # basicUnsafeRead :: MVector s Double -> Int -> ST s Double # basicUnsafeWrite :: MVector s Double -> Int -> Double -> ST s () # basicClear :: MVector s Double -> ST s () # basicSet :: MVector s Double -> Double -> ST s () # basicUnsafeCopy :: MVector s Double -> MVector s Double -> ST s () # basicUnsafeMove :: MVector s Double -> MVector s Double -> ST s () # basicUnsafeGrow :: MVector s Double -> Int -> ST s (MVector s Double) #
Generic1 (URec Double :: k -> Type)
Instance details Defined in GHC.Generics Associated Types type Rep1 (URec Double) :: k -> Type # Methods from1 :: forall (a :: k0). URec Double a -> Rep1 (URec Double) a # to1 :: forall (a :: k0). Rep1 (URec Double) a -> URec Double a #
Foldable (UDouble :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UDouble m -> m # foldMap :: Monoid m => (a -> m) -> UDouble a -> m # foldMap' :: Monoid m => (a -> m) -> UDouble a -> m # foldr :: (a -> b -> b) -> b -> UDouble a -> b # foldr' :: (a -> b -> b) -> b -> UDouble a -> b # foldl :: (b -> a -> b) -> b -> UDouble a -> b # foldl' :: (b -> a -> b) -> b -> UDouble a -> b # foldr1 :: (a -> a -> a) -> UDouble a -> a # foldl1 :: (a -> a -> a) -> UDouble a -> a # toList :: UDouble a -> [a] # null :: UDouble a -> Bool # length :: UDouble a -> Int # elem :: Eq a => a -> UDouble a -> Bool # maximum :: Ord a => UDouble a -> a # minimum :: Ord a => UDouble a -> a # sum :: Num a => UDouble a -> a # product :: Num a => UDouble a -> a #
Traversable (UDouble :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UDouble a -> f (UDouble b) # sequenceA :: Applicative f => UDouble (f a) -> f (UDouble a) # mapM :: Monad m => (a -> m b) -> UDouble a -> m (UDouble b) # sequence :: Monad m => UDouble (m a) -> m (UDouble a) #
Functor (URec Double :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec Double a -> URec Double b # (<$) :: a -> URec Double b -> URec Double a #
Generic (URec Double p)
Instance details Defined in GHC.Generics Associated Types type Rep (URec Double p) :: Type -> Type # Methods from :: URec Double p -> Rep (URec Double p) x # to :: Rep (URec Double p) x -> URec Double p #
Show (URec Double p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Double p -> ShowS # show :: URec Double p -> String # showList :: [URec Double p] -> ShowS #
Eq (URec Double p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: URec Double p -> URec Double p -> Bool # (/=) :: URec Double p -> URec Double p -> Bool #
Ord (URec Double p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: URec Double p -> URec Double p -> Ordering # (<) :: URec Double p -> URec Double p -> Bool # (<=) :: URec Double p -> URec Double p -> Bool # (>) :: URec Double p -> URec Double p -> Bool # (>=) :: URec Double p -> URec Double p -> Bool # max :: URec Double p -> URec Double p -> URec Double p # min :: URec Double p -> URec Double p -> URec Double p #
newtype Vector Double
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Double = V_Double (Vector Double)
data URec Double (p :: k)	Used for marking occurrences of `Double#` Since: base-4.9.0.0
Instance details Defined in GHC.Generics data URec Double (p :: k) = UDouble { uDouble# :: Double# }
newtype MVector s Double
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Double = MV_Double (MVector s Double)
type Rep1 (URec Double :: k -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep1 (URec Double :: k -> Type) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UDouble" 'PrefixI 'True) (S1 ('MetaSel ('Just "uDouble#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UDouble :: k -> Type)))
type Rep (URec Double p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep (URec Double p) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UDouble" 'PrefixI 'True) (S1 ('MetaSel ('Just "uDouble#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UDouble :: Type -> Type)))

data Float #

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

Instances

Instances details

Arbitrary Float
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen Float # shrink :: Float -> [Float] #
CoArbitrary Float
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Float -> Gen b -> Gen b #
Function Float
Instance details Defined in Test.QuickCheck.Function Methods function :: (Float -> b) -> Float :-> b #
Storable Float	Since: base-2.1
Instance details Defined in Foreign.Storable 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 () #
Floating Float	Since: base-2.1
Instance details Defined in GHC.Float Methods pi :: Float # exp :: Float -> Float # log :: Float -> Float # sqrt :: Float -> Float # (**) :: Float -> Float -> Float # logBase :: Float -> Float -> Float # sin :: Float -> Float # cos :: Float -> Float # tan :: Float -> Float # asin :: Float -> Float # acos :: Float -> Float # atan :: Float -> Float # sinh :: Float -> Float # cosh :: Float -> Float # tanh :: Float -> Float # asinh :: Float -> Float # acosh :: Float -> Float # atanh :: Float -> Float # log1p :: Float -> Float # expm1 :: Float -> Float # log1pexp :: Float -> Float # log1mexp :: Float -> Float #
RealFloat Float	Since: base-2.1
Instance details Defined in GHC.Float Methods floatRadix :: Float -> Integer # floatDigits :: Float -> Int # floatRange :: Float -> (Int, Int) # decodeFloat :: Float -> (Integer, Int) # encodeFloat :: Integer -> Int -> Float # exponent :: Float -> Int # significand :: Float -> Float # scaleFloat :: Int -> Float -> Float # isNaN :: Float -> Bool # isInfinite :: Float -> Bool # isDenormalized :: Float -> Bool # isNegativeZero :: Float -> Bool # isIEEE :: Float -> Bool # atan2 :: Float -> Float -> Float #
Read Float	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Float # readList :: ReadS [Float] # readPrec :: ReadPrec Float # readListPrec :: ReadPrec [Float] #
NFData Float
Instance details Defined in Control.DeepSeq Methods rnf :: Float -> () #
Eq Float	Note that due to the presence of `NaN`, `Float`'s `Eq` instance does not satisfy reflexivity. `>>>` `0/0 == (0/0 :: Float)`False Also note that `Float`'s `Eq` instance does not satisfy extensionality: `>>>` `0 == (-0 :: Float)`True `>>>` `recip 0 == recip (-0 :: Float)`False
Instance details Defined in GHC.Classes Methods (==) :: Float -> Float -> Bool # (/=) :: Float -> Float -> Bool #
Ord Float	Note that due to the presence of `NaN`, `Float`'s `Ord` instance does not satisfy reflexivity. `>>>` `0/0 <= (0/0 :: Float)`False Also note that, due to the same, `Ord`'s operator interactions are not respected by `Float`'s instance: `>>>` `(0/0 :: Float) > 1`False `>>>` `compare (0/0 :: Float) 1`GT
Instance details Defined in GHC.Classes Methods compare :: Float -> Float -> Ordering # (<) :: Float -> Float -> Bool # (<=) :: Float -> Float -> Bool # (>) :: Float -> Float -> Bool # (>=) :: Float -> Float -> Bool # max :: Float -> Float -> Float # min :: Float -> Float -> Float #
Random Float	Note - `random` produces values in the closed range `[0,1]`.
Instance details Defined in System.Random Methods randomR :: RandomGen g => (Float, Float) -> g -> (Float, g) # random :: RandomGen g => g -> (Float, g) # randomRs :: RandomGen g => (Float, Float) -> g -> [Float] # randoms :: RandomGen g => g -> [Float] #
UniformRange Float	See Floating point number caveats.
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (Float, Float) -> g -> m Float #
Unbox Float
Instance details Defined in Data.Vector.Unboxed.Base
Lift Float
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Float -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Float -> Code m Float #
Vector Vector Float
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s Float -> ST s (Vector Float) # basicUnsafeThaw :: Vector Float -> ST s (Mutable Vector s Float) # basicLength :: Vector Float -> Int # basicUnsafeSlice :: Int -> Int -> Vector Float -> Vector Float # basicUnsafeIndexM :: Vector Float -> Int -> Box Float # basicUnsafeCopy :: Mutable Vector s Float -> Vector Float -> ST s () # elemseq :: Vector Float -> Float -> b -> b #
MVector MVector Float
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Float -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Float -> MVector s Float # basicOverlaps :: MVector s Float -> MVector s Float -> Bool # basicUnsafeNew :: Int -> ST s (MVector s Float) # basicInitialize :: MVector s Float -> ST s () # basicUnsafeReplicate :: Int -> Float -> ST s (MVector s Float) # basicUnsafeRead :: MVector s Float -> Int -> ST s Float # basicUnsafeWrite :: MVector s Float -> Int -> Float -> ST s () # basicClear :: MVector s Float -> ST s () # basicSet :: MVector s Float -> Float -> ST s () # basicUnsafeCopy :: MVector s Float -> MVector s Float -> ST s () # basicUnsafeMove :: MVector s Float -> MVector s Float -> ST s () # basicUnsafeGrow :: MVector s Float -> Int -> ST s (MVector s Float) #
Generic1 (URec Float :: k -> Type)
Instance details Defined in GHC.Generics Associated Types type Rep1 (URec Float) :: k -> Type # Methods from1 :: forall (a :: k0). URec Float a -> Rep1 (URec Float) a # to1 :: forall (a :: k0). Rep1 (URec Float) a -> URec Float a #
Foldable (UFloat :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UFloat m -> m # foldMap :: Monoid m => (a -> m) -> UFloat a -> m # foldMap' :: Monoid m => (a -> m) -> UFloat a -> m # foldr :: (a -> b -> b) -> b -> UFloat a -> b # foldr' :: (a -> b -> b) -> b -> UFloat a -> b # foldl :: (b -> a -> b) -> b -> UFloat a -> b # foldl' :: (b -> a -> b) -> b -> UFloat a -> b # foldr1 :: (a -> a -> a) -> UFloat a -> a # foldl1 :: (a -> a -> a) -> UFloat a -> a # toList :: UFloat a -> [a] # null :: UFloat a -> Bool # length :: UFloat a -> Int # elem :: Eq a => a -> UFloat a -> Bool # maximum :: Ord a => UFloat a -> a # minimum :: Ord a => UFloat a -> a # sum :: Num a => UFloat a -> a # product :: Num a => UFloat a -> a #
Traversable (UFloat :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UFloat a -> f (UFloat b) # sequenceA :: Applicative f => UFloat (f a) -> f (UFloat a) # mapM :: Monad m => (a -> m b) -> UFloat a -> m (UFloat b) # sequence :: Monad m => UFloat (m a) -> m (UFloat a) #
Functor (URec Float :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec Float a -> URec Float b # (<$) :: a -> URec Float b -> URec Float a #
Generic (URec Float p)
Instance details Defined in GHC.Generics Associated Types type Rep (URec Float p) :: Type -> Type # Methods from :: URec Float p -> Rep (URec Float p) x # to :: Rep (URec Float p) x -> URec Float p #
Show (URec Float p)
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Float p -> ShowS # show :: URec Float p -> String # showList :: [URec Float p] -> ShowS #
Eq (URec Float p)
Instance details Defined in GHC.Generics Methods (==) :: URec Float p -> URec Float p -> Bool # (/=) :: URec Float p -> URec Float p -> Bool #
Ord (URec Float p)
Instance details Defined in GHC.Generics Methods compare :: URec Float p -> URec Float p -> Ordering # (<) :: URec Float p -> URec Float p -> Bool # (<=) :: URec Float p -> URec Float p -> Bool # (>) :: URec Float p -> URec Float p -> Bool # (>=) :: URec Float p -> URec Float p -> Bool # max :: URec Float p -> URec Float p -> URec Float p # min :: URec Float p -> URec Float p -> URec Float p #
newtype Vector Float
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Float = V_Float (Vector Float)
data URec Float (p :: k)	Used for marking occurrences of `Float#` Since: base-4.9.0.0
Instance details Defined in GHC.Generics data URec Float (p :: k) = UFloat { uFloat# :: Float# }
newtype MVector s Float
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Float = MV_Float (MVector s Float)
type Rep1 (URec Float :: k -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep1 (URec Float :: k -> Type) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UFloat" 'PrefixI 'True) (S1 ('MetaSel ('Just "uFloat#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UFloat :: k -> Type)))
type Rep (URec Float p)
Instance details Defined in GHC.Generics type Rep (URec Float p) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UFloat" 'PrefixI 'True) (S1 ('MetaSel ('Just "uFloat#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UFloat :: Type -> Type)))

data Int #

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

Instances

Instances details

Arbitrary Int
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen Int # shrink :: Int -> [Int] #
CoArbitrary Int
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Int -> Gen b -> Gen b #
Function Int
Instance details Defined in Test.QuickCheck.Function Methods function :: (Int -> b) -> Int :-> b #
IsString WriteTo
Instance details Defined in Raaz.Core.Transfer.Unsafe Methods fromString :: String -> WriteTo #
Storable Int	Since: base-2.1
Instance details Defined in Foreign.Storable 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 () #
Bits Int	Since: base-2.1
Instance details Defined in GHC.Bits 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 #
FiniteBits Int	Since: base-4.6.0.0
Instance details Defined in GHC.Bits Methods finiteBitSize :: Int -> Int # countLeadingZeros :: Int -> Int # countTrailingZeros :: Int -> Int #
Bounded Int	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Int # maxBound :: Int #
Enum Int	Since: base-2.1
Instance details Defined in GHC.Enum 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] #
Num Int	Since: base-2.1
Instance details Defined in GHC.Num Methods (+) :: Int -> Int -> Int # (-) :: Int -> Int -> Int # (*) :: Int -> Int -> Int # negate :: Int -> Int # abs :: Int -> Int # signum :: Int -> Int # fromInteger :: Integer -> Int #
Read Int	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Int # readList :: ReadS [Int] # readPrec :: ReadPrec Int # readListPrec :: ReadPrec [Int] #
Integral Int	Since: base-2.0.1
Instance details Defined in GHC.Real 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 #
Real Int	Since: base-2.0.1
Instance details Defined in GHC.Real Methods toRational :: Int -> Rational #
Show Int	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Int -> ShowS # show :: Int -> String # showList :: [Int] -> ShowS #
NFData Int
Instance details Defined in Control.DeepSeq Methods rnf :: Int -> () #
Eq Int
Instance details Defined in GHC.Classes Methods (==) :: Int -> Int -> Bool # (/=) :: Int -> Int -> Bool #
Ord Int
Instance details Defined in GHC.Classes Methods compare :: Int -> Int -> Ordering # (<) :: Int -> Int -> Bool # (<=) :: Int -> Int -> Bool # (>) :: Int -> Int -> Bool # (>=) :: Int -> Int -> Bool # max :: Int -> Int -> Int # min :: Int -> Int -> Int #
Encodable WriteTo
Instance details Defined in Raaz.Core.Transfer.Unsafe Methods toByteString :: WriteTo -> ByteString # fromByteString :: ByteString -> Maybe WriteTo # unsafeFromByteString :: ByteString -> WriteTo #
Random Int
Instance details Defined in System.Random Methods randomR :: RandomGen g => (Int, Int) -> g -> (Int, g) # random :: RandomGen g => g -> (Int, g) # randomRs :: RandomGen g => (Int, Int) -> g -> [Int] # randoms :: RandomGen g => g -> [Int] #
Uniform Int
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m Int #
UniformRange Int
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (Int, Int) -> g -> m Int #
Unbox Int
Instance details Defined in Data.Vector.Unboxed.Base
Lift Int
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Int -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Int -> Code m Int #
Vector Vector Int
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s Int -> ST s (Vector Int) # basicUnsafeThaw :: Vector Int -> ST s (Mutable Vector s Int) # basicLength :: Vector Int -> Int # basicUnsafeSlice :: Int -> Int -> Vector Int -> Vector Int # basicUnsafeIndexM :: Vector Int -> Int -> Box Int # basicUnsafeCopy :: Mutable Vector s Int -> Vector Int -> ST s () # elemseq :: Vector Int -> Int -> b -> b #
MVector MVector Int
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Int -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Int -> MVector s Int # basicOverlaps :: MVector s Int -> MVector s Int -> Bool # basicUnsafeNew :: Int -> ST s (MVector s Int) # basicInitialize :: MVector s Int -> ST s () # basicUnsafeReplicate :: Int -> Int -> ST s (MVector s Int) # basicUnsafeRead :: MVector s Int -> Int -> ST s Int # basicUnsafeWrite :: MVector s Int -> Int -> Int -> ST s () # basicClear :: MVector s Int -> ST s () # basicSet :: MVector s Int -> Int -> ST s () # basicUnsafeCopy :: MVector s Int -> MVector s Int -> ST s () # basicUnsafeMove :: MVector s Int -> MVector s Int -> ST s () # basicUnsafeGrow :: MVector s Int -> Int -> ST s (MVector s Int) #
Generic1 (URec Int :: k -> Type)
Instance details Defined in GHC.Generics Associated Types type Rep1 (URec Int) :: k -> Type # Methods from1 :: forall (a :: k0). URec Int a -> Rep1 (URec Int) a # to1 :: forall (a :: k0). Rep1 (URec Int) a -> URec Int a #
Foldable (UInt :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UInt m -> m # foldMap :: Monoid m => (a -> m) -> UInt a -> m # foldMap' :: Monoid m => (a -> m) -> UInt a -> m # foldr :: (a -> b -> b) -> b -> UInt a -> b # foldr' :: (a -> b -> b) -> b -> UInt a -> b # foldl :: (b -> a -> b) -> b -> UInt a -> b # foldl' :: (b -> a -> b) -> b -> UInt a -> b # foldr1 :: (a -> a -> a) -> UInt a -> a # foldl1 :: (a -> a -> a) -> UInt a -> a # toList :: UInt a -> [a] # null :: UInt a -> Bool # length :: UInt a -> Int # elem :: Eq a => a -> UInt a -> Bool # maximum :: Ord a => UInt a -> a # minimum :: Ord a => UInt a -> a # sum :: Num a => UInt a -> a # product :: Num a => UInt a -> a #
Traversable (UInt :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UInt a -> f (UInt b) # sequenceA :: Applicative f => UInt (f a) -> f (UInt a) # mapM :: Monad m => (a -> m b) -> UInt a -> m (UInt b) # sequence :: Monad m => UInt (m a) -> m (UInt a) #
LengthUnit (BYTES Int)
Instance details Defined in Raaz.Core.Types.Pointer Methods inBytes :: BYTES Int -> BYTES Int #
Distributive (BYTES Int) (TransferAction t)
Instance details Defined in Raaz.Core.Transfer.Unsafe
LAction (BYTES Int) (TransferAction t)
Instance details Defined in Raaz.Core.Transfer.Unsafe Methods (<.>) :: BYTES Int -> TransferAction t -> TransferAction t
Functor (URec Int :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec Int a -> URec Int b # (<$) :: a -> URec Int b -> URec Int a #
Generic (URec Int p)
Instance details Defined in GHC.Generics Associated Types type Rep (URec Int p) :: Type -> Type # Methods from :: URec Int p -> Rep (URec Int p) x # to :: Rep (URec Int p) x -> URec Int p #
Show (URec Int p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Int p -> ShowS # show :: URec Int p -> String # showList :: [URec Int p] -> ShowS #
Eq (URec Int p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: URec Int p -> URec Int p -> Bool # (/=) :: URec Int p -> URec Int p -> Bool #
Ord (URec Int p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: URec Int p -> URec Int p -> Ordering # (<) :: URec Int p -> URec Int p -> Bool # (<=) :: URec Int p -> URec Int p -> Bool # (>) :: URec Int p -> URec Int p -> Bool # (>=) :: URec Int p -> URec Int p -> Bool # max :: URec Int p -> URec Int p -> URec Int p # min :: URec Int p -> URec Int p -> URec Int p #
newtype Vector Int
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Int = V_Int (Vector Int)
data URec Int (p :: k)	Used for marking occurrences of `Int#` Since: base-4.9.0.0
Instance details Defined in GHC.Generics data URec Int (p :: k) = UInt { uInt# :: Int# }
newtype MVector s Int
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Int = MV_Int (MVector s Int)
type Rep1 (URec Int :: k -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep1 (URec Int :: k -> Type) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UInt" 'PrefixI 'True) (S1 ('MetaSel ('Just "uInt#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UInt :: k -> Type)))
type Rep (URec Int p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep (URec Int p) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UInt" 'PrefixI 'True) (S1 ('MetaSel ('Just "uInt#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UInt :: Type -> Type)))

data Word #

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

Instances

Instances details

Arbitrary Word
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen Word # shrink :: Word -> [Word] #
CoArbitrary Word
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Word -> Gen b -> Gen b #
Function Word
Instance details Defined in Test.QuickCheck.Function Methods function :: (Word -> b) -> Word :-> b #
Storable Word	Since: base-2.1
Instance details Defined in Foreign.Storable 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 () #
Bits Word	Since: base-2.1
Instance details Defined in GHC.Bits Methods (.&.) :: Word -> Word -> Word # (.\|.) :: Word -> Word -> Word # xor :: Word -> Word -> Word # complement :: Word -> Word # shift :: Word -> Int -> Word # rotate :: Word -> Int -> Word # zeroBits :: Word # bit :: Int -> Word # setBit :: Word -> Int -> Word # clearBit :: Word -> Int -> Word # complementBit :: Word -> Int -> Word # testBit :: Word -> Int -> Bool # bitSizeMaybe :: Word -> Maybe Int # bitSize :: Word -> Int # isSigned :: Word -> Bool # shiftL :: Word -> Int -> Word # unsafeShiftL :: Word -> Int -> Word # shiftR :: Word -> Int -> Word # unsafeShiftR :: Word -> Int -> Word # rotateL :: Word -> Int -> Word # rotateR :: Word -> Int -> Word # popCount :: Word -> Int #
FiniteBits Word	Since: base-4.6.0.0
Instance details Defined in GHC.Bits Methods finiteBitSize :: Word -> Int # countLeadingZeros :: Word -> Int # countTrailingZeros :: Word -> Int #
Bounded Word	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Word # maxBound :: Word #
Enum Word	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Word -> Word # pred :: Word -> Word # toEnum :: Int -> Word # fromEnum :: Word -> Int # enumFrom :: Word -> [Word] # enumFromThen :: Word -> Word -> [Word] # enumFromTo :: Word -> Word -> [Word] # enumFromThenTo :: Word -> Word -> Word -> [Word] #
Num Word	Since: base-2.1
Instance details Defined in GHC.Num Methods (+) :: Word -> Word -> Word # (-) :: Word -> Word -> Word # (*) :: Word -> Word -> Word # negate :: Word -> Word # abs :: Word -> Word # signum :: Word -> Word # fromInteger :: Integer -> Word #
Read Word	Since: base-4.5.0.0
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Word # readList :: ReadS [Word] # readPrec :: ReadPrec Word # readListPrec :: ReadPrec [Word] #
Integral Word	Since: base-2.1
Instance details Defined in GHC.Real 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 #
Real Word	Since: base-2.1
Instance details Defined in GHC.Real Methods toRational :: Word -> Rational #
Show Word	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Word -> ShowS # show :: Word -> String # showList :: [Word] -> ShowS #
NFData Word
Instance details Defined in Control.DeepSeq Methods rnf :: Word -> () #
Eq Word
Instance details Defined in GHC.Classes Methods (==) :: Word -> Word -> Bool # (/=) :: Word -> Word -> Bool #
Ord Word
Instance details Defined in GHC.Classes Methods compare :: Word -> Word -> Ordering # (<) :: Word -> Word -> Bool # (<=) :: Word -> Word -> Bool # (>) :: Word -> Word -> Bool # (>=) :: Word -> Word -> Bool # max :: Word -> Word -> Word # min :: Word -> Word -> Word #
Equality Word
Instance details Defined in Raaz.Core.Types.Equality Methods eq :: Word -> Word -> Result #
Random Word
Instance details Defined in System.Random Methods randomR :: RandomGen g => (Word, Word) -> g -> (Word, g) # random :: RandomGen g => g -> (Word, g) # randomRs :: RandomGen g => (Word, Word) -> g -> [Word] # randoms :: RandomGen g => g -> [Word] #
Uniform Word
Instance details Defined in System.Random.Internal Methods uniformM :: StatefulGen g m => g -> m Word #
UniformRange Word
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (Word, Word) -> g -> m Word #
Unbox Word
Instance details Defined in Data.Vector.Unboxed.Base
Lift Word
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Word -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Word -> Code m Word #
Vector Vector Word
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: Mutable Vector s Word -> ST s (Vector Word) # basicUnsafeThaw :: Vector Word -> ST s (Mutable Vector s Word) # basicLength :: Vector Word -> Int # basicUnsafeSlice :: Int -> Int -> Vector Word -> Vector Word # basicUnsafeIndexM :: Vector Word -> Int -> Box Word # basicUnsafeCopy :: Mutable Vector s Word -> Vector Word -> ST s () # elemseq :: Vector Word -> Word -> b -> b #
MVector MVector Word
Instance details Defined in Data.Vector.Unboxed.Base Methods basicLength :: MVector s Word -> Int # basicUnsafeSlice :: Int -> Int -> MVector s Word -> MVector s Word # basicOverlaps :: MVector s Word -> MVector s Word -> Bool # basicUnsafeNew :: Int -> ST s (MVector s Word) # basicInitialize :: MVector s Word -> ST s () # basicUnsafeReplicate :: Int -> Word -> ST s (MVector s Word) # basicUnsafeRead :: MVector s Word -> Int -> ST s Word # basicUnsafeWrite :: MVector s Word -> Int -> Word -> ST s () # basicClear :: MVector s Word -> ST s () # basicSet :: MVector s Word -> Word -> ST s () # basicUnsafeCopy :: MVector s Word -> MVector s Word -> ST s () # basicUnsafeMove :: MVector s Word -> MVector s Word -> ST s () # basicUnsafeGrow :: MVector s Word -> Int -> ST s (MVector s Word) #
Generic1 (URec Word :: k -> Type)
Instance details Defined in GHC.Generics Associated Types type Rep1 (URec Word) :: k -> Type # Methods from1 :: forall (a :: k0). URec Word a -> Rep1 (URec Word) a # to1 :: forall (a :: k0). Rep1 (URec Word) a -> URec Word a #
Foldable (UWord :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UWord m -> m # foldMap :: Monoid m => (a -> m) -> UWord a -> m # foldMap' :: Monoid m => (a -> m) -> UWord a -> m # foldr :: (a -> b -> b) -> b -> UWord a -> b # foldr' :: (a -> b -> b) -> b -> UWord a -> b # foldl :: (b -> a -> b) -> b -> UWord a -> b # foldl' :: (b -> a -> b) -> b -> UWord a -> b # foldr1 :: (a -> a -> a) -> UWord a -> a # foldl1 :: (a -> a -> a) -> UWord a -> a # toList :: UWord a -> [a] # null :: UWord a -> Bool # length :: UWord a -> Int # elem :: Eq a => a -> UWord a -> Bool # maximum :: Ord a => UWord a -> a # minimum :: Ord a => UWord a -> a # sum :: Num a => UWord a -> a # product :: Num a => UWord a -> a #
Traversable (UWord :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UWord a -> f (UWord b) # sequenceA :: Applicative f => UWord (f a) -> f (UWord a) # mapM :: Monad m => (a -> m b) -> UWord a -> m (UWord b) # sequence :: Monad m => UWord (m a) -> m (UWord a) #
Functor (URec Word :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec Word a -> URec Word b # (<$) :: a -> URec Word b -> URec Word a #
Generic (URec Word p)
Instance details Defined in GHC.Generics Associated Types type Rep (URec Word p) :: Type -> Type # Methods from :: URec Word p -> Rep (URec Word p) x # to :: Rep (URec Word p) x -> URec Word p #
Show (URec Word p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Word p -> ShowS # show :: URec Word p -> String # showList :: [URec Word p] -> ShowS #
Eq (URec Word p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: URec Word p -> URec Word p -> Bool # (/=) :: URec Word p -> URec Word p -> Bool #
Ord (URec Word p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: URec Word p -> URec Word p -> Ordering # (<) :: URec Word p -> URec Word p -> Bool # (<=) :: URec Word p -> URec Word p -> Bool # (>) :: URec Word p -> URec Word p -> Bool # (>=) :: URec Word p -> URec Word p -> Bool # max :: URec Word p -> URec Word p -> URec Word p # min :: URec Word p -> URec Word p -> URec Word p #
newtype Vector Word
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Word = V_Word (Vector Word)
data URec Word (p :: k)	Used for marking occurrences of `Word#` Since: base-4.9.0.0
Instance details Defined in GHC.Generics data URec Word (p :: k) = UWord { uWord# :: Word# }
newtype MVector s Word
Instance details Defined in Data.Vector.Unboxed.Base newtype MVector s Word = MV_Word (MVector s Word)
type Rep1 (URec Word :: k -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep1 (URec Word :: k -> Type) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UWord" 'PrefixI 'True) (S1 ('MetaSel ('Just "uWord#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UWord :: k -> Type)))
type Rep (URec Word p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep (URec Word p) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UWord" 'PrefixI 'True) (S1 ('MetaSel ('Just "uWord#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UWord :: Type -> Type)))

data Ordering #

Constructors

LT
EQ
GT

Instances

Instances details

Arbitrary Ordering
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen Ordering # shrink :: Ordering -> [Ordering] #
CoArbitrary Ordering
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Ordering -> Gen b -> Gen b #
Function Ordering
Instance details Defined in Test.QuickCheck.Function Methods function :: (Ordering -> b) -> Ordering :-> b #
Monoid Ordering	Since: base-2.1
Instance details Defined in GHC.Base Methods mempty :: Ordering # mappend :: Ordering -> Ordering -> Ordering # mconcat :: [Ordering] -> Ordering #
Semigroup Ordering	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (<>) :: Ordering -> Ordering -> Ordering # sconcat :: NonEmpty Ordering -> Ordering # stimes :: Integral b => b -> Ordering -> Ordering #
Bounded Ordering	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Ordering # maxBound :: Ordering #
Enum Ordering	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Ordering -> Ordering # pred :: Ordering -> Ordering # toEnum :: Int -> Ordering # fromEnum :: Ordering -> Int # enumFrom :: Ordering -> [Ordering] # enumFromThen :: Ordering -> Ordering -> [Ordering] # enumFromTo :: Ordering -> Ordering -> [Ordering] # enumFromThenTo :: Ordering -> Ordering -> Ordering -> [Ordering] #
Generic Ordering
Instance details Defined in GHC.Generics Associated Types type Rep Ordering :: Type -> Type # Methods from :: Ordering -> Rep Ordering x # to :: Rep Ordering x -> Ordering #
Read Ordering	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Ordering # readList :: ReadS [Ordering] # readPrec :: ReadPrec Ordering # readListPrec :: ReadPrec [Ordering] #
Show Ordering	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Ordering -> ShowS # show :: Ordering -> String # showList :: [Ordering] -> ShowS #
NFData Ordering
Instance details Defined in Control.DeepSeq Methods rnf :: Ordering -> () #
Eq Ordering
Instance details Defined in GHC.Classes Methods (==) :: Ordering -> Ordering -> Bool # (/=) :: Ordering -> Ordering -> Bool #
Ord Ordering
Instance details Defined in GHC.Classes Methods compare :: Ordering -> Ordering -> Ordering # (<) :: Ordering -> Ordering -> Bool # (<=) :: Ordering -> Ordering -> Bool # (>) :: Ordering -> Ordering -> Bool # (>=) :: Ordering -> Ordering -> Bool # max :: Ordering -> Ordering -> Ordering # min :: Ordering -> Ordering -> Ordering #
type Rep Ordering	Since: base-4.6.0.0
Instance details Defined in GHC.Generics type Rep Ordering = D1 ('MetaData "Ordering" "GHC.Types" "ghc-prim" 'False) (C1 ('MetaCons "LT" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "EQ" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "GT" 'PrefixI 'False) (U1 :: Type -> Type)))

data Maybe a #

The Maybe type encapsulates an optional value. A value of type Maybe a either contains a value of type a (represented as Just a), or it is empty (represented as Nothing). Using Maybe is a good way to deal with errors or exceptional cases without resorting to drastic measures such as error.

The Maybe type is also a monad. It is a simple kind of error monad, where all errors are represented by Nothing. A richer error monad can be built using the Either type.

Constructors

Nothing
Just a

Instances

Instances details

Arbitrary1 Maybe
Instance details Defined in Test.QuickCheck.Arbitrary Methods liftArbitrary :: Gen a -> Gen (Maybe a) # liftShrink :: (a -> [a]) -> Maybe a -> [Maybe a] #
MonadFail Maybe	Since: base-4.9.0.0
Instance details Defined in Control.Monad.Fail Methods fail :: String -> Maybe a #
Foldable Maybe	Since: base-2.1
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Maybe m -> m # foldMap :: Monoid m => (a -> m) -> Maybe a -> m # foldMap' :: Monoid m => (a -> m) -> Maybe a -> m # foldr :: (a -> b -> b) -> b -> Maybe a -> b # foldr' :: (a -> b -> b) -> b -> Maybe a -> b # foldl :: (b -> a -> b) -> b -> Maybe a -> b # foldl' :: (b -> a -> b) -> b -> Maybe a -> b # foldr1 :: (a -> a -> a) -> Maybe a -> a # foldl1 :: (a -> a -> a) -> Maybe a -> a # toList :: Maybe a -> [a] # null :: Maybe a -> Bool # length :: Maybe a -> Int # elem :: Eq a => a -> Maybe a -> Bool # maximum :: Ord a => Maybe a -> a # minimum :: Ord a => Maybe a -> a # sum :: Num a => Maybe a -> a # product :: Num a => Maybe a -> a #
Traversable Maybe	Since: base-2.1
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> Maybe a -> f (Maybe b) # sequenceA :: Applicative f => Maybe (f a) -> f (Maybe a) # mapM :: Monad m => (a -> m b) -> Maybe a -> m (Maybe b) # sequence :: Monad m => Maybe (m a) -> m (Maybe a) #
Alternative Maybe	Picks the leftmost `Just` value, or, alternatively, `Nothing`. Since: base-2.1
Instance details Defined in GHC.Base Methods empty :: Maybe a # (<\|>) :: Maybe a -> Maybe a -> Maybe a # some :: Maybe a -> Maybe [a] # many :: Maybe a -> Maybe [a] #
Applicative Maybe	Since: base-2.1
Instance details Defined in GHC.Base Methods pure :: a -> Maybe a # (<>) :: Maybe (a -> b) -> Maybe a -> Maybe b # liftA2 :: (a -> b -> c) -> Maybe a -> Maybe b -> Maybe c # (>) :: Maybe a -> Maybe b -> Maybe b # (<*) :: Maybe a -> Maybe b -> Maybe a #
Functor Maybe	Since: base-2.1
Instance details Defined in GHC.Base Methods fmap :: (a -> b) -> Maybe a -> Maybe b # (<$) :: a -> Maybe b -> Maybe a #
Monad Maybe	Since: base-2.1
Instance details Defined in GHC.Base Methods (>>=) :: Maybe a -> (a -> Maybe b) -> Maybe b # (>>) :: Maybe a -> Maybe b -> Maybe b # return :: a -> Maybe a #
MonadPlus Maybe	Picks the leftmost `Just` value, or, alternatively, `Nothing`. Since: base-2.1
Instance details Defined in GHC.Base Methods mzero :: Maybe a # mplus :: Maybe a -> Maybe a -> Maybe a #
NFData1 Maybe	Since: deepseq-1.4.3.0
Instance details Defined in Control.DeepSeq Methods liftRnf :: (a -> ()) -> Maybe a -> () #
Generic1 Maybe
Instance details Defined in GHC.Generics Associated Types type Rep1 Maybe :: k -> Type # Methods from1 :: forall (a :: k). Maybe a -> Rep1 Maybe a # to1 :: forall (a :: k). Rep1 Maybe a -> Maybe a #
Lift a => Lift (Maybe a :: Type)
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Maybe a -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Maybe a -> Code m (Maybe a) #
Arbitrary a => Arbitrary (Maybe a)
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (Maybe a) # shrink :: Maybe a -> [Maybe a] #
CoArbitrary a => CoArbitrary (Maybe a)
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Maybe a -> Gen b -> Gen b #
Function a => Function (Maybe a)
Instance details Defined in Test.QuickCheck.Function Methods function :: (Maybe a -> b) -> Maybe a :-> b #
Testable prop => Testable (Maybe prop)
Instance details Defined in Test.QuickCheck.Property Methods property :: Maybe prop -> Property # propertyForAllShrinkShow :: Gen a -> (a -> [a]) -> (a -> [String]) -> (a -> Maybe prop) -> Property #
Semigroup a => Monoid (Maybe a)	Lift a semigroup into `Maybe` forming a `Monoid` according to http://en.wikipedia.org/wiki/Monoid: "Any semigroup `S` may be turned into a monoid simply by adjoining an element `e` not in `S` and defining `ee = e` and `es = s = se` for all `s ∈ S`." Since 4.11.0: constraint on inner `a` value generalised from `Monoid` to `Semigroup`. Since: base-2.1*
Instance details Defined in GHC.Base Methods mempty :: Maybe a # mappend :: Maybe a -> Maybe a -> Maybe a # mconcat :: [Maybe a] -> Maybe a #
Semigroup a => Semigroup (Maybe a)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (<>) :: Maybe a -> Maybe a -> Maybe a # sconcat :: NonEmpty (Maybe a) -> Maybe a # stimes :: Integral b => b -> Maybe a -> Maybe a #
Generic (Maybe a)
Instance details Defined in GHC.Generics Associated Types type Rep (Maybe a) :: Type -> Type # Methods from :: Maybe a -> Rep (Maybe a) x # to :: Rep (Maybe a) x -> Maybe a #
SingKind a => SingKind (Maybe a)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Associated Types type DemoteRep (Maybe a) Methods fromSing :: forall (a0 :: Maybe a). Sing a0 -> DemoteRep (Maybe a)
Read a => Read (Maybe a)	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS (Maybe a) # readList :: ReadS [Maybe a] # readPrec :: ReadPrec (Maybe a) # readListPrec :: ReadPrec [Maybe a] #
Show a => Show (Maybe a)	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Maybe a -> ShowS # show :: Maybe a -> String # showList :: [Maybe a] -> ShowS #
NFData a => NFData (Maybe a)
Instance details Defined in Control.DeepSeq Methods rnf :: Maybe a -> () #
Eq a => Eq (Maybe a)	Since: base-2.1
Instance details Defined in GHC.Maybe Methods (==) :: Maybe a -> Maybe a -> Bool # (/=) :: Maybe a -> Maybe a -> Bool #
Ord a => Ord (Maybe a)	Since: base-2.1
Instance details Defined in GHC.Maybe Methods compare :: Maybe a -> Maybe a -> Ordering # (<) :: Maybe a -> Maybe a -> Bool # (<=) :: Maybe a -> Maybe a -> Bool # (>) :: Maybe a -> Maybe a -> Bool # (>=) :: Maybe a -> Maybe a -> Bool # max :: Maybe a -> Maybe a -> Maybe a # min :: Maybe a -> Maybe a -> Maybe a #
ByteSource src => ByteSource (Maybe src)
Instance details Defined in Raaz.Core.ByteSource Methods fillBytes :: BYTES Int -> Maybe src -> Ptr a -> IO (FillResult (Maybe src)) #
PureByteSource src => PureByteSource (Maybe src)
Instance details Defined in Raaz.Core.ByteSource
SingI ('Nothing :: Maybe a)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods sing :: Sing 'Nothing
SingI a2 => SingI ('Just a2 :: Maybe a1)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods sing :: Sing ('Just a2)
type Rep1 Maybe	Since: base-4.6.0.0
Instance details Defined in GHC.Generics type Rep1 Maybe = D1 ('MetaData "Maybe" "GHC.Maybe" "base" 'False) (C1 ('MetaCons "Nothing" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Just" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1))
type DemoteRep (Maybe a)
Instance details Defined in GHC.Generics type DemoteRep (Maybe a) = Maybe (DemoteRep a)
type Rep (Maybe a)	Since: base-4.6.0.0
Instance details Defined in GHC.Generics type Rep (Maybe a) = D1 ('MetaData "Maybe" "GHC.Maybe" "base" 'False) (C1 ('MetaCons "Nothing" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Just" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)))
data Sing (b :: Maybe a)
Instance details Defined in GHC.Generics data Sing (b :: Maybe a) where SNothing :: forall {a}. Sing ('Nothing :: Maybe a) SJust :: forall {a} (a1 :: a). Sing a1 -> Sing ('Just a1)

class a ~# b => (a :: k) ~ (b :: k) infix 4 #

Lifted, homogeneous equality. By lifted, we mean that it can be bogus (deferred type error). By homogeneous, the two types a and b must have the same kinds.

data Integer #

Arbitrary precision integers. In contrast with fixed-size integral types such as Int, the Integer type represents the entire infinite range of integers.

Integers are stored in a kind of sign-magnitude form, hence do not expect two's complement form when using bit operations.

If the value is small (fit into an Int), IS constructor is used. Otherwise Integer and IN constructors are used to store a BigNat representing respectively the positive or the negative value magnitude.

Invariant: Integer and IN are used iff value doesn't fit in IS

Instances

Instances details

Arbitrary Integer
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen Integer # shrink :: Integer -> [Integer] #
CoArbitrary Integer
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Integer -> Gen b -> Gen b #
Function Integer
Instance details Defined in Test.QuickCheck.Function Methods function :: (Integer -> b) -> Integer :-> b #
Bits Integer	Since: base-2.1
Instance details Defined in GHC.Bits Methods (.&.) :: Integer -> Integer -> Integer # (.\|.) :: Integer -> Integer -> Integer # xor :: Integer -> Integer -> Integer # complement :: Integer -> Integer # shift :: Integer -> Int -> Integer # rotate :: Integer -> Int -> Integer # zeroBits :: Integer # bit :: Int -> Integer # setBit :: Integer -> Int -> Integer # clearBit :: Integer -> Int -> Integer # complementBit :: Integer -> Int -> Integer # testBit :: Integer -> Int -> Bool # bitSizeMaybe :: Integer -> Maybe Int # bitSize :: Integer -> Int # isSigned :: Integer -> Bool # shiftL :: Integer -> Int -> Integer # unsafeShiftL :: Integer -> Int -> Integer # shiftR :: Integer -> Int -> Integer # unsafeShiftR :: Integer -> Int -> Integer # rotateL :: Integer -> Int -> Integer # rotateR :: Integer -> Int -> Integer # popCount :: Integer -> Int #
Enum Integer	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Integer -> Integer # pred :: Integer -> Integer # toEnum :: Int -> Integer # fromEnum :: Integer -> Int # enumFrom :: Integer -> [Integer] # enumFromThen :: Integer -> Integer -> [Integer] # enumFromTo :: Integer -> Integer -> [Integer] # enumFromThenTo :: Integer -> Integer -> Integer -> [Integer] #
Num Integer	Since: base-2.1
Instance details Defined in GHC.Num Methods (+) :: Integer -> Integer -> Integer # (-) :: Integer -> Integer -> Integer # (*) :: Integer -> Integer -> Integer # negate :: Integer -> Integer # abs :: Integer -> Integer # signum :: Integer -> Integer # fromInteger :: Integer -> Integer #
Read Integer	Since: base-2.1
Instance details Defined in GHC.Read Methods readsPrec :: Int -> ReadS Integer # readList :: ReadS [Integer] # readPrec :: ReadPrec Integer # readListPrec :: ReadPrec [Integer] #
Integral Integer	Since: base-2.0.1
Instance details Defined in GHC.Real Methods quot :: Integer -> Integer -> Integer # rem :: Integer -> Integer -> Integer # div :: Integer -> Integer -> Integer # mod :: Integer -> Integer -> Integer # quotRem :: Integer -> Integer -> (Integer, Integer) # divMod :: Integer -> Integer -> (Integer, Integer) # toInteger :: Integer -> Integer #
Real Integer	Since: base-2.0.1
Instance details Defined in GHC.Real Methods toRational :: Integer -> Rational #
Show Integer	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Integer -> ShowS # show :: Integer -> String # showList :: [Integer] -> ShowS #
NFData Integer
Instance details Defined in Control.DeepSeq Methods rnf :: Integer -> () #
Eq Integer
Instance details Defined in GHC.Num.Integer Methods (==) :: Integer -> Integer -> Bool # (/=) :: Integer -> Integer -> Bool #
Ord Integer
Instance details Defined in GHC.Num.Integer Methods compare :: Integer -> Integer -> Ordering # (<) :: Integer -> Integer -> Bool # (<=) :: Integer -> Integer -> Bool # (>) :: Integer -> Integer -> Bool # (>=) :: Integer -> Integer -> Bool # max :: Integer -> Integer -> Integer # min :: Integer -> Integer -> Integer #
Random Integer	Note - `random` generates values in the `Int` range
Instance details Defined in System.Random Methods randomR :: RandomGen g => (Integer, Integer) -> g -> (Integer, g) # random :: RandomGen g => g -> (Integer, g) # randomRs :: RandomGen g => (Integer, Integer) -> g -> [Integer] # randoms :: RandomGen g => g -> [Integer] #
UniformRange Integer
Instance details Defined in System.Random.Internal Methods uniformRM :: StatefulGen g m => (Integer, Integer) -> g -> m Integer #
Lift Integer
Instance details Defined in Language.Haskell.TH.Syntax Methods lift :: Quote m => Integer -> m Exp # liftTyped :: forall (m :: Type -> Type). Quote m => Integer -> Code m Integer #

data IO a #

A value of type IO a is a computation which, when performed, does some I/O before returning a value of type a.

There is really only one way to "perform" an I/O action: bind it to Main.main in your program. When your program is run, the I/O will be performed. It isn't possible to perform I/O from an arbitrary function, unless that function is itself in the IO monad and called at some point, directly or indirectly, from Main.main.

IO is a monad, so IO actions can be combined using either the do-notation or the >> and >>= operations from the Monad class.

Instances

Instances details

MonadFail IO	Since: base-4.9.0.0
Instance details Defined in Control.Monad.Fail Methods fail :: String -> IO a #
MonadIO IO	Since: base-4.9.0.0
Instance details Defined in Control.Monad.IO.Class Methods liftIO :: IO a -> IO a #
Alternative IO	Takes the first non-throwing `IO` action's result. `empty` throws an exception. Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods empty :: IO a # (<\|>) :: IO a -> IO a -> IO a # some :: IO a -> IO [a] # many :: IO a -> IO [a] #
Applicative IO	Since: base-2.1
Instance details Defined in GHC.Base Methods pure :: a -> IO a # (<>) :: IO (a -> b) -> IO a -> IO b # liftA2 :: (a -> b -> c) -> IO a -> IO b -> IO c # (>) :: IO a -> IO b -> IO b # (<*) :: IO a -> IO b -> IO a #
Functor IO	Since: base-2.1
Instance details Defined in GHC.Base Methods fmap :: (a -> b) -> IO a -> IO b # (<$) :: a -> IO b -> IO a #
Monad IO	Since: base-2.1
Instance details Defined in GHC.Base Methods (>>=) :: IO a -> (a -> IO b) -> IO b # (>>) :: IO a -> IO b -> IO b # return :: a -> IO a #
MonadPlus IO	Takes the first non-throwing `IO` action's result. `mzero` throws an exception. Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods mzero :: IO a # mplus :: IO a -> IO a -> IO a #
Example Expectation
Instance details Defined in Test.Hspec.Core.Example Associated Types type Arg Expectation # Methods evaluateExample :: Expectation -> Params -> (ActionWith (Arg Expectation) -> IO ()) -> ProgressCallback -> IO Result #
PrimBase IO
Instance details Defined in Control.Monad.Primitive Methods internal :: IO a -> State# (PrimState IO) -> (# State# (PrimState IO), a #) #
PrimMonad IO
Instance details Defined in Control.Monad.Primitive Associated Types type PrimState IO # Methods primitive :: (State# (PrimState IO) -> (# State# (PrimState IO), a #)) -> IO a #
Quasi IO
Instance details Defined in Language.Haskell.TH.Syntax Methods qNewName :: String -> IO Name # qReport :: Bool -> String -> IO () # qRecover :: IO a -> IO a -> IO a # qLookupName :: Bool -> String -> IO (Maybe Name) # qReify :: Name -> IO Info # qReifyFixity :: Name -> IO (Maybe Fixity) # qReifyType :: Name -> IO Type # qReifyInstances :: Name -> [Type] -> IO [Dec] # qReifyRoles :: Name -> IO [Role] # qReifyAnnotations :: Data a => AnnLookup -> IO [a] # qReifyModule :: Module -> IO ModuleInfo # qReifyConStrictness :: Name -> IO [DecidedStrictness] # qLocation :: IO Loc # qRunIO :: IO a -> IO a # qGetPackageRoot :: IO FilePath # qAddDependentFile :: FilePath -> IO () # qAddTempFile :: String -> IO FilePath # qAddTopDecls :: [Dec] -> IO () # qAddForeignFilePath :: ForeignSrcLang -> String -> IO () # qAddModFinalizer :: Q () -> IO () # qAddCorePlugin :: String -> IO () # qGetQ :: Typeable a => IO (Maybe a) # qPutQ :: Typeable a => a -> IO () # qIsExtEnabled :: Extension -> IO Bool # qExtsEnabled :: IO [Extension] # qPutDoc :: DocLoc -> String -> IO () # qGetDoc :: DocLoc -> IO (Maybe String) #
Quote IO
Instance details Defined in Language.Haskell.TH.Syntax Methods newName :: String -> IO Name #
Monoid a => Monoid (IO a)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods mempty :: IO a # mappend :: IO a -> IO a -> IO a # mconcat :: [IO a] -> IO a #
Semigroup a => Semigroup (IO a)	Since: base-4.10.0.0
Instance details Defined in GHC.Base Methods (<>) :: IO a -> IO a -> IO a # sconcat :: NonEmpty (IO a) -> IO a # stimes :: Integral b => b -> IO a -> IO a #
Example (a -> Expectation)
Instance details Defined in Test.Hspec.Core.Example Associated Types type Arg (a -> Expectation) # Methods evaluateExample :: (a -> Expectation) -> Params -> (ActionWith (Arg (a -> Expectation)) -> IO ()) -> ProgressCallback -> IO Result #
type Arg Expectation
Instance details Defined in Test.Hspec.Core.Example type Arg Expectation = ()
type PrimState IO
Instance details Defined in Control.Monad.Primitive type PrimState IO = RealWorld
type Arg (a -> Expectation)
Instance details Defined in Test.Hspec.Core.Example type Arg (a -> Expectation) = a

type Type = TYPE LiftedRep #

The kind of types with lifted values. For example Int :: Type.

type Constraint = CONSTRAINT LiftedRep #

The kind of lifted constraints

class Show a where #

Conversion of values to readable Strings.

Derived instances of Show have the following properties, which are compatible with derived instances of Read:

The result of show is a syntactically correct Haskell expression containing only constants, given the fixity declarations in force at the point where the type is declared. It contains only the constructor names defined in the data type, parentheses, and spaces. When labelled constructor fields are used, braces, commas, field names, and equal signs are also used.
If the constructor is defined to be an infix operator, then showsPrec will produce infix applications of the constructor.
the representation will be enclosed in parentheses if the precedence of the top-level constructor in x is less than d (associativity is ignored). Thus, if d is 0 then the result is never surrounded in parentheses; if d is 11 it is always surrounded in parentheses, unless it is an atomic expression.
If the constructor is defined using record syntax, then show will produce the record-syntax form, with the fields given in the same order as the original declaration.

For example, given the declarations

infixr 5 :^:
data Tree a =  Leaf a  |  Tree a :^: Tree a

the derived instance of Show is equivalent to

instance (Show a) => Show (Tree a) where

       showsPrec d (Leaf m) = showParen (d > app_prec) $
            showString "Leaf " . showsPrec (app_prec+1) m
         where app_prec = 10

       showsPrec d (u :^: v) = showParen (d > up_prec) $
            showsPrec (up_prec+1) u .
            showString " :^: "      .
            showsPrec (up_prec+1) v
         where up_prec = 5

Note that right-associativity of :^: is ignored. For example,

show (Leaf 1 :^: Leaf 2 :^: Leaf 3) produces the string "Leaf 1 :^: (Leaf 2 :^: Leaf 3)".

Minimal complete definition

showsPrec | show

Methods

showsPrec #

Arguments

:: Int	the operator precedence of the enclosing context (a number from `0` to `11`). Function application has precedence `10`.
-> a	the value to be converted to a `String`
-> ShowS

Convert a value to a readable String.

showsPrec should satisfy the law

showsPrec d x r ++ s  ==  showsPrec d x (r ++ s)

Derived instances of Read and Show satisfy the following:

(x,"") is an element of (readsPrec d (showsPrec d x "")).

That is, readsPrec parses the string produced by showsPrec, and delivers the value that showsPrec started with.

show :: a -> String #

A specialised variant of showsPrec, using precedence context zero, and returning an ordinary String.

showList :: [a] -> ShowS #

The method showList is provided to allow the programmer to give a specialised way of showing lists of values. For example, this is used by the predefined Show instance of the Char type, where values of type String should be shown in double quotes, rather than between square brackets.

Instances

Instances details

Show FailureReason
Instance details Defined in Test.HUnit.Lang Methods showsPrec :: Int -> FailureReason -> ShowS # show :: FailureReason -> String # showList :: [FailureReason] -> ShowS #
Show HUnitFailure
Instance details Defined in Test.HUnit.Lang Methods showsPrec :: Int -> HUnitFailure -> ShowS # show :: HUnitFailure -> String # showList :: [HUnitFailure] -> ShowS #
Show Result
Instance details Defined in Test.HUnit.Lang Methods showsPrec :: Int -> Result -> ShowS # show :: Result -> String # showList :: [Result] -> ShowS #
Show ASCIIString
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> ASCIIString -> ShowS # show :: ASCIIString -> String # showList :: [ASCIIString] -> ShowS #
Show PrintableString
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> PrintableString -> ShowS # show :: PrintableString -> String # showList :: [PrintableString] -> ShowS #
Show UnicodeString
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> UnicodeString -> ShowS # show :: UnicodeString -> String # showList :: [UnicodeString] -> ShowS #
Show Witness
Instance details Defined in Test.QuickCheck.Property Methods showsPrec :: Int -> Witness -> ShowS # show :: Witness -> String # showList :: [Witness] -> ShowS #
Show QCGen
Instance details Defined in Test.QuickCheck.Random Methods showsPrec :: Int -> QCGen -> ShowS # show :: QCGen -> String # showList :: [QCGen] -> ShowS #
Show Confidence
Instance details Defined in Test.QuickCheck.State Methods showsPrec :: Int -> Confidence -> ShowS # show :: Confidence -> String # showList :: [Confidence] -> ShowS #
Show Args
Instance details Defined in Test.QuickCheck.Test Methods showsPrec :: Int -> Args -> ShowS # show :: Args -> String # showList :: [Args] -> ShowS #
Show Result
Instance details Defined in Test.QuickCheck.Test Methods showsPrec :: Int -> Result -> ShowS # show :: Result -> String # showList :: [Result] -> ShowS #
Show SomeTypeRep	Since: base-4.10.0.0
Instance details Defined in Data.Typeable.Internal Methods showsPrec :: Int -> SomeTypeRep -> ShowS # show :: SomeTypeRep -> String # showList :: [SomeTypeRep] -> ShowS #
Show IntPtr
Instance details Defined in Foreign.Ptr Methods showsPrec :: Int -> IntPtr -> ShowS # show :: IntPtr -> String # showList :: [IntPtr] -> ShowS #
Show WordPtr
Instance details Defined in Foreign.Ptr Methods showsPrec :: Int -> WordPtr -> ShowS # show :: WordPtr -> String # showList :: [WordPtr] -> ShowS #
Show Void	Since: base-4.8.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Void -> ShowS # show :: Void -> String # showList :: [Void] -> ShowS #
Show ErrorCall	Since: base-4.0.0.0
Instance details Defined in GHC.Exception Methods showsPrec :: Int -> ErrorCall -> ShowS # show :: ErrorCall -> String # showList :: [ErrorCall] -> ShowS #
Show ArithException	Since: base-4.0.0.0
Instance details Defined in GHC.Exception.Type Methods showsPrec :: Int -> ArithException -> ShowS # show :: ArithException -> String # showList :: [ArithException] -> ShowS #
Show SomeException	Since: base-3.0
Instance details Defined in GHC.Exception.Type Methods showsPrec :: Int -> SomeException -> ShowS # show :: SomeException -> String # showList :: [SomeException] -> ShowS #
Show Associativity	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> Associativity -> ShowS # show :: Associativity -> String # showList :: [Associativity] -> ShowS #
Show DecidedStrictness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> DecidedStrictness -> ShowS # show :: DecidedStrictness -> String # showList :: [DecidedStrictness] -> ShowS #
Show Fixity	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> Fixity -> ShowS # show :: Fixity -> String # showList :: [Fixity] -> ShowS #
Show SourceStrictness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> SourceStrictness -> ShowS # show :: SourceStrictness -> String # showList :: [SourceStrictness] -> ShowS #
Show SourceUnpackedness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> SourceUnpackedness -> ShowS # show :: SourceUnpackedness -> String # showList :: [SourceUnpackedness] -> ShowS #
Show MaskingState	Since: base-4.3.0.0
Instance details Defined in GHC.IO Methods showsPrec :: Int -> MaskingState -> ShowS # show :: MaskingState -> String # showList :: [MaskingState] -> ShowS #
Show SeekMode	Since: base-4.2.0.0
Instance details Defined in GHC.IO.Device Methods showsPrec :: Int -> SeekMode -> ShowS # show :: SeekMode -> String # showList :: [SeekMode] -> ShowS #
Show CodingProgress	Since: base-4.4.0.0
Instance details Defined in GHC.IO.Encoding.Types Methods showsPrec :: Int -> CodingProgress -> ShowS # show :: CodingProgress -> String # showList :: [CodingProgress] -> ShowS #
Show TextEncoding	Since: base-4.3.0.0
Instance details Defined in GHC.IO.Encoding.Types Methods showsPrec :: Int -> TextEncoding -> ShowS # show :: TextEncoding -> String # showList :: [TextEncoding] -> ShowS #
Show AllocationLimitExceeded	Since: base-4.7.1.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> AllocationLimitExceeded -> ShowS # show :: AllocationLimitExceeded -> String # showList :: [AllocationLimitExceeded] -> ShowS #
Show ArrayException	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> ArrayException -> ShowS # show :: ArrayException -> String # showList :: [ArrayException] -> ShowS #
Show AssertionFailed	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> AssertionFailed -> ShowS # show :: AssertionFailed -> String # showList :: [AssertionFailed] -> ShowS #
Show AsyncException	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> AsyncException -> ShowS # show :: AsyncException -> String # showList :: [AsyncException] -> ShowS #
Show BlockedIndefinitelyOnMVar	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> BlockedIndefinitelyOnMVar -> ShowS # show :: BlockedIndefinitelyOnMVar -> String # showList :: [BlockedIndefinitelyOnMVar] -> ShowS #
Show BlockedIndefinitelyOnSTM	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> BlockedIndefinitelyOnSTM -> ShowS # show :: BlockedIndefinitelyOnSTM -> String # showList :: [BlockedIndefinitelyOnSTM] -> ShowS #
Show CompactionFailed	Since: base-4.10.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> CompactionFailed -> ShowS # show :: CompactionFailed -> String # showList :: [CompactionFailed] -> ShowS #
Show Deadlock	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> Deadlock -> ShowS # show :: Deadlock -> String # showList :: [Deadlock] -> ShowS #
Show ExitCode
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> ExitCode -> ShowS # show :: ExitCode -> String # showList :: [ExitCode] -> ShowS #
Show FixIOException	Since: base-4.11.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> FixIOException -> ShowS # show :: FixIOException -> String # showList :: [FixIOException] -> ShowS #
Show IOErrorType	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> IOErrorType -> ShowS # show :: IOErrorType -> String # showList :: [IOErrorType] -> ShowS #
Show IOException	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> IOException -> ShowS # show :: IOException -> String # showList :: [IOException] -> ShowS #
Show SomeAsyncException	Since: base-4.7.0.0
Instance details Defined in GHC.IO.Exception Methods showsPrec :: Int -> SomeAsyncException -> ShowS # show :: SomeAsyncException -> String # showList :: [SomeAsyncException] -> ShowS #
Show HandlePosn	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Handle Methods showsPrec :: Int -> HandlePosn -> ShowS # show :: HandlePosn -> String # showList :: [HandlePosn] -> ShowS #
Show BufferMode	Since: base-4.2.0.0
Instance details Defined in GHC.IO.Handle.Types Methods showsPrec :: Int -> BufferMode -> ShowS # show :: BufferMode -> String # showList :: [BufferMode] -> ShowS #
Show Handle	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Handle.Types Methods showsPrec :: Int -> Handle -> ShowS # show :: Handle -> String # showList :: [Handle] -> ShowS #
Show HandleType	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Handle.Types Methods showsPrec :: Int -> HandleType -> ShowS # show :: HandleType -> String # showList :: [HandleType] -> ShowS #
Show Newline	Since: base-4.3.0.0
Instance details Defined in GHC.IO.Handle.Types Methods showsPrec :: Int -> Newline -> ShowS # show :: Newline -> String # showList :: [Newline] -> ShowS #
Show NewlineMode	Since: base-4.3.0.0
Instance details Defined in GHC.IO.Handle.Types Methods showsPrec :: Int -> NewlineMode -> ShowS # show :: NewlineMode -> String # showList :: [NewlineMode] -> ShowS #
Show IOMode	Since: base-4.2.0.0
Instance details Defined in GHC.IO.IOMode Methods showsPrec :: Int -> IOMode -> ShowS # show :: IOMode -> String # showList :: [IOMode] -> ShowS #
Show FractionalExponentBase
Instance details Defined in GHC.Real Methods showsPrec :: Int -> FractionalExponentBase -> ShowS # show :: FractionalExponentBase -> String # showList :: [FractionalExponentBase] -> ShowS #
Show CallStack	Since: base-4.9.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> CallStack -> ShowS # show :: CallStack -> String # showList :: [CallStack] -> ShowS #
Show SrcLoc	Since: base-4.9.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> SrcLoc -> ShowS # show :: SrcLoc -> String # showList :: [SrcLoc] -> ShowS #
Show SomeNat	Since: base-4.7.0.0
Instance details Defined in GHC.TypeNats Methods showsPrec :: Int -> SomeNat -> ShowS # show :: SomeNat -> String # showList :: [SomeNat] -> ShowS #
Show Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods showsPrec :: Int -> Word16 -> ShowS # show :: Word16 -> String # showList :: [Word16] -> ShowS #
Show Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods showsPrec :: Int -> Word32 -> ShowS # show :: Word32 -> String # showList :: [Word32] -> ShowS #
Show Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods showsPrec :: Int -> Word64 -> ShowS # show :: Word64 -> String # showList :: [Word64] -> ShowS #
Show Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods showsPrec :: Int -> Word8 -> ShowS # show :: Word8 -> String # showList :: [Word8] -> ShowS #
Show ByteString
Instance details Defined in Data.ByteString.Internal.Type Methods showsPrec :: Int -> ByteString -> ShowS # show :: ByteString -> String # showList :: [ByteString] -> ShowS #
Show ShortByteString
Instance details Defined in Data.ByteString.Short.Internal Methods showsPrec :: Int -> ShortByteString -> ShowS # show :: ShortByteString -> String # showList :: [ShortByteString] -> ShowS #
Show IntSet
Instance details Defined in Data.IntSet.Internal Methods showsPrec :: Int -> IntSet -> ShowS # show :: IntSet -> String # showList :: [IntSet] -> ShowS #
Show OsChar
Instance details Defined in System.OsString.Internal.Types Methods showsPrec :: Int -> OsChar -> ShowS # show :: OsChar -> String # showList :: [OsChar] -> ShowS #
Show OsString	On windows, decodes as UCS-2. On unix prints the raw bytes without decoding.
Instance details Defined in System.OsString.Internal.Types Methods showsPrec :: Int -> OsString -> ShowS # show :: OsString -> String # showList :: [OsString] -> ShowS #
Show PosixChar
Instance details Defined in System.OsString.Internal.Types Methods showsPrec :: Int -> PosixChar -> ShowS # show :: PosixChar -> String # showList :: [PosixChar] -> ShowS #
Show PosixString	Prints the raw bytes without decoding.
Instance details Defined in System.OsString.Internal.Types Methods showsPrec :: Int -> PosixString -> ShowS # show :: PosixString -> String # showList :: [PosixString] -> ShowS #
Show WindowsChar
Instance details Defined in System.OsString.Internal.Types Methods showsPrec :: Int -> WindowsChar -> ShowS # show :: WindowsChar -> String # showList :: [WindowsChar] -> ShowS #
Show WindowsString	Decodes as UCS-2.
Instance details Defined in System.OsString.Internal.Types Methods showsPrec :: Int -> WindowsString -> ShowS # show :: WindowsString -> String # showList :: [WindowsString] -> ShowS #
Show KindRep
Instance details Defined in GHC.Show Methods showsPrec :: Int -> KindRep -> ShowS # show :: KindRep -> String # showList :: [KindRep] -> ShowS #
Show Module	Since: base-4.9.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Module -> ShowS # show :: Module -> String # showList :: [Module] -> ShowS #
Show Ordering	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Ordering -> ShowS # show :: Ordering -> String # showList :: [Ordering] -> ShowS #
Show TrName	Since: base-4.9.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> TrName -> ShowS # show :: TrName -> String # showList :: [TrName] -> ShowS #
Show TyCon	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> TyCon -> ShowS # show :: TyCon -> String # showList :: [TyCon] -> ShowS #
Show TypeLitSort	Since: base-4.11.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> TypeLitSort -> ShowS # show :: TypeLitSort -> String # showList :: [TypeLitSort] -> ShowS #
Show FailureReason
Instance details Defined in Test.Hspec.Core.Example Methods showsPrec :: Int -> FailureReason -> ShowS # show :: FailureReason -> String # showList :: [FailureReason] -> ShowS #
Show Params
Instance details Defined in Test.Hspec.Core.Example Methods showsPrec :: Int -> Params -> ShowS # show :: Params -> String # showList :: [Params] -> ShowS #
Show Result
Instance details Defined in Test.Hspec.Core.Example Methods showsPrec :: Int -> Result -> ShowS # show :: Result -> String # showList :: [Result] -> ShowS #
Show ResultStatus
Instance details Defined in Test.Hspec.Core.Example Methods showsPrec :: Int -> ResultStatus -> ShowS # show :: ResultStatus -> String # showList :: [ResultStatus] -> ShowS #
Show ProgressReporting
Instance details Defined in Test.Hspec.Core.Runner Methods showsPrec :: Int -> ProgressReporting -> ShowS # show :: ProgressReporting -> String # showList :: [ProgressReporting] -> ShowS #
Show UseColor
Instance details Defined in Test.Hspec.Core.Runner Methods showsPrec :: Int -> UseColor -> ShowS # show :: UseColor -> String # showList :: [UseColor] -> ShowS #
Show Mode
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods showsPrec :: Int -> Mode -> ShowS # show :: Mode -> String # showList :: [Mode] -> ShowS #
Show Style
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods showsPrec :: Int -> Style -> ShowS # show :: Style -> String # showList :: [Style] -> ShowS #
Show TextDetails
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods showsPrec :: Int -> TextDetails -> ShowS # show :: TextDetails -> String # showList :: [TextDetails] -> ShowS #
Show Doc
Instance details Defined in Text.PrettyPrint.HughesPJ Methods showsPrec :: Int -> Doc -> ShowS # show :: Doc -> String # showList :: [Doc] -> ShowS #
Show Base16
Instance details Defined in Raaz.Core.Encode.Base16 Methods showsPrec :: Int -> Base16 -> ShowS # show :: Base16 -> String # showList :: [Base16] -> ShowS #
Show Base64
Instance details Defined in Raaz.Core.Encode.Base64 Methods showsPrec :: Int -> Base64 -> ShowS # show :: Base64 -> String # showList :: [Base64] -> ShowS #
Show Alignment
Instance details Defined in Raaz.Core.Types.Pointer Methods showsPrec :: Int -> Alignment -> ShowS # show :: Alignment -> String # showList :: [Alignment] -> ShowS #
Show Poly1305
Instance details Defined in Raaz.Primitive.Poly1305.Internal Methods showsPrec :: Int -> Poly1305 -> ShowS # show :: Poly1305 -> String # showList :: [Poly1305] -> ShowS #
Show R
Instance details Defined in Raaz.Primitive.Poly1305.Internal Methods showsPrec :: Int -> R -> ShowS # show :: R -> String # showList :: [R] -> ShowS #
Show S
Instance details Defined in Raaz.Primitive.Poly1305.Internal Methods showsPrec :: Int -> S -> ShowS # show :: S -> String # showList :: [S] -> ShowS #
Show StdGen
Instance details Defined in System.Random.Internal Methods showsPrec :: Int -> StdGen -> ShowS # show :: StdGen -> String # showList :: [StdGen] -> ShowS #
Show AnnLookup
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> AnnLookup -> ShowS # show :: AnnLookup -> String # showList :: [AnnLookup] -> ShowS #
Show AnnTarget
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> AnnTarget -> ShowS # show :: AnnTarget -> String # showList :: [AnnTarget] -> ShowS #
Show Bang
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Bang -> ShowS # show :: Bang -> String # showList :: [Bang] -> ShowS #
Show Body
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Body -> ShowS # show :: Body -> String # showList :: [Body] -> ShowS #
Show Bytes
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Bytes -> ShowS # show :: Bytes -> String # showList :: [Bytes] -> ShowS #
Show Callconv
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Callconv -> ShowS # show :: Callconv -> String # showList :: [Callconv] -> ShowS #
Show Clause
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Clause -> ShowS # show :: Clause -> String # showList :: [Clause] -> ShowS #
Show Con
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Con -> ShowS # show :: Con -> String # showList :: [Con] -> ShowS #
Show Dec
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Dec -> ShowS # show :: Dec -> String # showList :: [Dec] -> ShowS #
Show DecidedStrictness
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> DecidedStrictness -> ShowS # show :: DecidedStrictness -> String # showList :: [DecidedStrictness] -> ShowS #
Show DerivClause
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> DerivClause -> ShowS # show :: DerivClause -> String # showList :: [DerivClause] -> ShowS #
Show DerivStrategy
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> DerivStrategy -> ShowS # show :: DerivStrategy -> String # showList :: [DerivStrategy] -> ShowS #
Show DocLoc
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> DocLoc -> ShowS # show :: DocLoc -> String # showList :: [DocLoc] -> ShowS #
Show Exp
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Exp -> ShowS # show :: Exp -> String # showList :: [Exp] -> ShowS #
Show FamilyResultSig
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> FamilyResultSig -> ShowS # show :: FamilyResultSig -> String # showList :: [FamilyResultSig] -> ShowS #
Show Fixity
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Fixity -> ShowS # show :: Fixity -> String # showList :: [Fixity] -> ShowS #
Show FixityDirection
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> FixityDirection -> ShowS # show :: FixityDirection -> String # showList :: [FixityDirection] -> ShowS #
Show Foreign
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Foreign -> ShowS # show :: Foreign -> String # showList :: [Foreign] -> ShowS #
Show FunDep
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> FunDep -> ShowS # show :: FunDep -> String # showList :: [FunDep] -> ShowS #
Show Guard
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Guard -> ShowS # show :: Guard -> String # showList :: [Guard] -> ShowS #
Show Info
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Info -> ShowS # show :: Info -> String # showList :: [Info] -> ShowS #
Show InjectivityAnn
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> InjectivityAnn -> ShowS # show :: InjectivityAnn -> String # showList :: [InjectivityAnn] -> ShowS #
Show Inline
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Inline -> ShowS # show :: Inline -> String # showList :: [Inline] -> ShowS #
Show Lit
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Lit -> ShowS # show :: Lit -> String # showList :: [Lit] -> ShowS #
Show Loc
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Loc -> ShowS # show :: Loc -> String # showList :: [Loc] -> ShowS #
Show Match
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Match -> ShowS # show :: Match -> String # showList :: [Match] -> ShowS #
Show ModName
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> ModName -> ShowS # show :: ModName -> String # showList :: [ModName] -> ShowS #
Show Module
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Module -> ShowS # show :: Module -> String # showList :: [Module] -> ShowS #
Show ModuleInfo
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> ModuleInfo -> ShowS # show :: ModuleInfo -> String # showList :: [ModuleInfo] -> ShowS #
Show Name
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Name -> ShowS # show :: Name -> String # showList :: [Name] -> ShowS #
Show NameFlavour
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> NameFlavour -> ShowS # show :: NameFlavour -> String # showList :: [NameFlavour] -> ShowS #
Show NameSpace
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> NameSpace -> ShowS # show :: NameSpace -> String # showList :: [NameSpace] -> ShowS #
Show OccName
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> OccName -> ShowS # show :: OccName -> String # showList :: [OccName] -> ShowS #
Show Overlap
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Overlap -> ShowS # show :: Overlap -> String # showList :: [Overlap] -> ShowS #
Show Pat
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Pat -> ShowS # show :: Pat -> String # showList :: [Pat] -> ShowS #
Show PatSynArgs
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> PatSynArgs -> ShowS # show :: PatSynArgs -> String # showList :: [PatSynArgs] -> ShowS #
Show PatSynDir
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> PatSynDir -> ShowS # show :: PatSynDir -> String # showList :: [PatSynDir] -> ShowS #
Show Phases
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Phases -> ShowS # show :: Phases -> String # showList :: [Phases] -> ShowS #
Show PkgName
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> PkgName -> ShowS # show :: PkgName -> String # showList :: [PkgName] -> ShowS #
Show Pragma
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Pragma -> ShowS # show :: Pragma -> String # showList :: [Pragma] -> ShowS #
Show Range
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Range -> ShowS # show :: Range -> String # showList :: [Range] -> ShowS #
Show Role
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Role -> ShowS # show :: Role -> String # showList :: [Role] -> ShowS #
Show RuleBndr
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> RuleBndr -> ShowS # show :: RuleBndr -> String # showList :: [RuleBndr] -> ShowS #
Show RuleMatch
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> RuleMatch -> ShowS # show :: RuleMatch -> String # showList :: [RuleMatch] -> ShowS #
Show Safety
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Safety -> ShowS # show :: Safety -> String # showList :: [Safety] -> ShowS #
Show SourceStrictness
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> SourceStrictness -> ShowS # show :: SourceStrictness -> String # showList :: [SourceStrictness] -> ShowS #
Show SourceUnpackedness
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> SourceUnpackedness -> ShowS # show :: SourceUnpackedness -> String # showList :: [SourceUnpackedness] -> ShowS #
Show Specificity
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Specificity -> ShowS # show :: Specificity -> String # showList :: [Specificity] -> ShowS #
Show Stmt
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Stmt -> ShowS # show :: Stmt -> String # showList :: [Stmt] -> ShowS #
Show TyLit
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> TyLit -> ShowS # show :: TyLit -> String # showList :: [TyLit] -> ShowS #
Show TySynEqn
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> TySynEqn -> ShowS # show :: TySynEqn -> String # showList :: [TySynEqn] -> ShowS #
Show Type
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> Type -> ShowS # show :: Type -> String # showList :: [Type] -> ShowS #
Show TypeFamilyHead
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> TypeFamilyHead -> ShowS # show :: TypeFamilyHead -> String # showList :: [TypeFamilyHead] -> ShowS #
Show LocalTime
Instance details Defined in Data.Time.LocalTime.Internal.LocalTime Methods showsPrec :: Int -> LocalTime -> ShowS # show :: LocalTime -> String # showList :: [LocalTime] -> ShowS #
Show ZonedTime	For the time zone, this only shows the name, or offset if the name is empty.
Instance details Defined in Data.Time.LocalTime.Internal.ZonedTime Methods showsPrec :: Int -> ZonedTime -> ShowS # show :: ZonedTime -> String # showList :: [ZonedTime] -> ShowS #
Show Integer	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Integer -> ShowS # show :: Integer -> String # showList :: [Integer] -> ShowS #
Show Natural	Since: base-4.8.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Natural -> ShowS # show :: Natural -> String # showList :: [Natural] -> ShowS #
Show ()	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> () -> ShowS # show :: () -> String # showList :: [()] -> ShowS #
Show Bool	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Bool -> ShowS # show :: Bool -> String # showList :: [Bool] -> ShowS #
Show Char	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Char -> ShowS # show :: Char -> String # showList :: [Char] -> ShowS #
Show Int	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Int -> ShowS # show :: Int -> String # showList :: [Int] -> ShowS #
Show Levity	Since: base-4.15.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Levity -> ShowS # show :: Levity -> String # showList :: [Levity] -> ShowS #
Show RuntimeRep	Since: base-4.11.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> RuntimeRep -> ShowS # show :: RuntimeRep -> String # showList :: [RuntimeRep] -> ShowS #
Show VecCount	Since: base-4.11.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> VecCount -> ShowS # show :: VecCount -> String # showList :: [VecCount] -> ShowS #
Show VecElem	Since: base-4.11.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> VecElem -> ShowS # show :: VecElem -> String # showList :: [VecElem] -> ShowS #
Show Word	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Word -> ShowS # show :: Word -> String # showList :: [Word] -> ShowS #
Show (Blind a)
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> Blind a -> ShowS # show :: Blind a -> String # showList :: [Blind a] -> ShowS #
Show a => Show (Fixed a)
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> Fixed a -> ShowS # show :: Fixed a -> String # showList :: [Fixed a] -> ShowS #
Show a => Show (InfiniteList a)
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> InfiniteList a -> ShowS # show :: InfiniteList a -> String # showList :: [InfiniteList a] -> ShowS #
Show a => Show (Large a)
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> Large a -> ShowS # show :: Large a -> String # showList :: [Large a] -> ShowS #
Show a => Show (Negative a)
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> Negative a -> ShowS # show :: Negative a -> String # showList :: [Negative a] -> ShowS #
Show a => Show (NonEmptyList a)
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> NonEmptyList a -> ShowS # show :: NonEmptyList a -> String # showList :: [NonEmptyList a] -> ShowS #
Show a => Show (NonNegative a)
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> NonNegative a -> ShowS # show :: NonNegative a -> String # showList :: [NonNegative a] -> ShowS #
Show a => Show (NonPositive a)
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> NonPositive a -> ShowS # show :: NonPositive a -> String # showList :: [NonPositive a] -> ShowS #
Show a => Show (NonZero a)
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> NonZero a -> ShowS # show :: NonZero a -> String # showList :: [NonZero a] -> ShowS #
Show a => Show (OrderedList a)
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> OrderedList a -> ShowS # show :: OrderedList a -> String # showList :: [OrderedList a] -> ShowS #
Show a => Show (Positive a)
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> Positive a -> ShowS # show :: Positive a -> String # showList :: [Positive a] -> ShowS #
Show a => Show (Shrink2 a)
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> Shrink2 a -> ShowS # show :: Shrink2 a -> String # showList :: [Shrink2 a] -> ShowS #
Show a => Show (Small a)
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> Small a -> ShowS # show :: Small a -> String # showList :: [Small a] -> ShowS #
Show a => Show (Smart a)
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> Smart a -> ShowS # show :: Smart a -> String # showList :: [Smart a] -> ShowS #
Show a => Show (SortedList a)
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> SortedList a -> ShowS # show :: SortedList a -> String # showList :: [SortedList a] -> ShowS #
Show a => Show (ZipList a)	Since: base-4.7.0.0
Instance details Defined in Control.Applicative Methods showsPrec :: Int -> ZipList a -> ShowS # show :: ZipList a -> String # showList :: [ZipList a] -> ShowS #
Show a => Show (And a)	Since: base-4.16
Instance details Defined in Data.Bits Methods showsPrec :: Int -> And a -> ShowS # show :: And a -> String # showList :: [And a] -> ShowS #
Show a => Show (Iff a)	Since: base-4.16
Instance details Defined in Data.Bits Methods showsPrec :: Int -> Iff a -> ShowS # show :: Iff a -> String # showList :: [Iff a] -> ShowS #
Show a => Show (Ior a)	Since: base-4.16
Instance details Defined in Data.Bits Methods showsPrec :: Int -> Ior a -> ShowS # show :: Ior a -> String # showList :: [Ior a] -> ShowS #
Show a => Show (Xor a)	Since: base-4.16
Instance details Defined in Data.Bits Methods showsPrec :: Int -> Xor a -> ShowS # show :: Xor a -> String # showList :: [Xor a] -> ShowS #
Show a => Show (NonEmpty a)	Since: base-4.11.0.0
Instance details Defined in GHC.Show Methods showsPrec :: Int -> NonEmpty a -> ShowS # show :: NonEmpty a -> String # showList :: [NonEmpty a] -> ShowS #
Show p => Show (Par1 p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> Par1 p -> ShowS # show :: Par1 p -> String # showList :: [Par1 p] -> ShowS #
Show (FunPtr a)	Since: base-2.1
Instance details Defined in GHC.Ptr Methods showsPrec :: Int -> FunPtr a -> ShowS # show :: FunPtr a -> String # showList :: [FunPtr a] -> ShowS #
Show (Ptr a)	Since: base-2.1
Instance details Defined in GHC.Ptr Methods showsPrec :: Int -> Ptr a -> ShowS # show :: Ptr a -> String # showList :: [Ptr a] -> ShowS #
Show a => Show (Ratio a)	Since: base-2.0.1
Instance details Defined in GHC.Real Methods showsPrec :: Int -> Ratio a -> ShowS # show :: Ratio a -> String # showList :: [Ratio a] -> ShowS #
Show (SNat n)	Since: base-4.18.0.0
Instance details Defined in GHC.TypeNats Methods showsPrec :: Int -> SNat n -> ShowS # show :: SNat n -> String # showList :: [SNat n] -> ShowS #
Show a => Show (IntMap a)
Instance details Defined in Data.IntMap.Internal Methods showsPrec :: Int -> IntMap a -> ShowS # show :: IntMap a -> String # showList :: [IntMap a] -> ShowS #
Show a => Show (Seq a)
Instance details Defined in Data.Sequence.Internal Methods showsPrec :: Int -> Seq a -> ShowS # show :: Seq a -> String # showList :: [Seq a] -> ShowS #
Show a => Show (ViewL a)
Instance details Defined in Data.Sequence.Internal Methods showsPrec :: Int -> ViewL a -> ShowS # show :: ViewL a -> String # showList :: [ViewL a] -> ShowS #
Show a => Show (ViewR a)
Instance details Defined in Data.Sequence.Internal Methods showsPrec :: Int -> ViewR a -> ShowS # show :: ViewR a -> String # showList :: [ViewR a] -> ShowS #
Show a => Show (Intersection a)
Instance details Defined in Data.Set.Internal Methods showsPrec :: Int -> Intersection a -> ShowS # show :: Intersection a -> String # showList :: [Intersection a] -> ShowS #
Show a => Show (Set a)
Instance details Defined in Data.Set.Internal Methods showsPrec :: Int -> Set a -> ShowS # show :: Set a -> String # showList :: [Set a] -> ShowS #
Show a => Show (Tree a)
Instance details Defined in Data.Tree Methods showsPrec :: Int -> Tree a -> ShowS # show :: Tree a -> String # showList :: [Tree a] -> ShowS #
Show a => Show (AnnotDetails a)
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods showsPrec :: Int -> AnnotDetails a -> ShowS # show :: AnnotDetails a -> String # showList :: [AnnotDetails a] -> ShowS #
Show (Doc a)
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods showsPrec :: Int -> Doc a -> ShowS # show :: Doc a -> String # showList :: [Doc a] -> ShowS #
Show a => Show (Span a)
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods showsPrec :: Int -> Span a -> ShowS # show :: Span a -> String # showList :: [Span a] -> ShowS #
Show a => Show (Array a)
Instance details Defined in Data.Primitive.Array Methods showsPrec :: Int -> Array a -> ShowS # show :: Array a -> String # showList :: [Array a] -> ShowS #
(Show a, Prim a) => Show (PrimArray a)	Since: primitive-0.6.4.0
Instance details Defined in Data.Primitive.PrimArray Methods showsPrec :: Int -> PrimArray a -> ShowS # show :: PrimArray a -> String # showList :: [PrimArray a] -> ShowS #
Show a => Show (SmallArray a)
Instance details Defined in Data.Primitive.SmallArray Methods showsPrec :: Int -> SmallArray a -> ShowS # show :: SmallArray a -> String # showList :: [SmallArray a] -> ShowS #
Show a => Show (FillResult a)
Instance details Defined in Raaz.Core.ByteSource Methods showsPrec :: Int -> FillResult a -> ShowS # show :: FillResult a -> String # showList :: [FillResult a] -> ShowS #
Show (BlockCount p)
Instance details Defined in Raaz.Core.Primitive Methods showsPrec :: Int -> BlockCount p -> ShowS # show :: BlockCount p -> String # showList :: [BlockCount p] -> ShowS #
Show (Key ChaCha20)
Instance details Defined in Raaz.Primitive.ChaCha20.Internal Methods showsPrec :: Int -> Key ChaCha20 -> ShowS # show :: Key ChaCha20 -> String # showList :: [Key ChaCha20] -> ShowS #
Show (Key XChaCha20)
Instance details Defined in Raaz.Primitive.ChaCha20.Internal Methods showsPrec :: Int -> Key XChaCha20 -> ShowS # show :: Key XChaCha20 -> String # showList :: [Key XChaCha20] -> ShowS #
Show (Key (Keyed prim))
Instance details Defined in Raaz.Primitive.Keyed.Internal Methods showsPrec :: Int -> Key (Keyed prim) -> ShowS # show :: Key (Keyed prim) -> String # showList :: [Key (Keyed prim)] -> ShowS #
Show (Key Poly1305)
Instance details Defined in Raaz.Primitive.Poly1305.Internal Methods showsPrec :: Int -> Key Poly1305 -> ShowS # show :: Key Poly1305 -> String # showList :: [Key Poly1305] -> ShowS #
Show (Nounce ChaCha20)
Instance details Defined in Raaz.Primitive.ChaCha20.Internal Methods showsPrec :: Int -> Nounce ChaCha20 -> ShowS # show :: Nounce ChaCha20 -> String # showList :: [Nounce ChaCha20] -> ShowS #
Show (Nounce XChaCha20)
Instance details Defined in Raaz.Primitive.ChaCha20.Internal Methods showsPrec :: Int -> Nounce XChaCha20 -> ShowS # show :: Nounce XChaCha20 -> String # showList :: [Nounce XChaCha20] -> ShowS #
Show w => Show (BE w)
Instance details Defined in Raaz.Core.Types.Endian Methods showsPrec :: Int -> BE w -> ShowS # show :: BE w -> String # showList :: [BE w] -> ShowS #
Show w => Show (LE w)
Instance details Defined in Raaz.Core.Types.Endian Methods showsPrec :: Int -> LE w -> ShowS # show :: LE w -> String # showList :: [LE w] -> ShowS #
Show a => Show (BYTES a)
Instance details Defined in Raaz.Core.Types.Pointer Methods showsPrec :: Int -> BYTES a -> ShowS # show :: BYTES a -> String # showList :: [BYTES a] -> ShowS #
(EndianStore w, Unbox w) => Show (Blake2 w)
Instance details Defined in Raaz.Primitive.Blake2.Internal Methods showsPrec :: Int -> Blake2 w -> ShowS # show :: Blake2 w -> String # showList :: [Blake2 w] -> ShowS #
Show prim => Show (Keyed prim)
Instance details Defined in Raaz.Primitive.Keyed.Internal Methods showsPrec :: Int -> Keyed prim -> ShowS # show :: Keyed prim -> String # showList :: [Keyed prim] -> ShowS #
(EndianStore w, Unbox w) => Show (Sha2 w)
Instance details Defined in Raaz.Primitive.Sha2.Internal Methods showsPrec :: Int -> Sha2 w -> ShowS # show :: Sha2 w -> String # showList :: [Sha2 w] -> ShowS #
Show g => Show (StateGen g)
Instance details Defined in System.Random.Internal Methods showsPrec :: Int -> StateGen g -> ShowS # show :: StateGen g -> String # showList :: [StateGen g] -> ShowS #
Show flag => Show (TyVarBndr flag)
Instance details Defined in Language.Haskell.TH.Syntax Methods showsPrec :: Int -> TyVarBndr flag -> ShowS # show :: TyVarBndr flag -> String # showList :: [TyVarBndr flag] -> ShowS #
(Show a, Prim a) => Show (Vector a)
Instance details Defined in Data.Vector.Primitive Methods showsPrec :: Int -> Vector a -> ShowS # show :: Vector a -> String # showList :: [Vector a] -> ShowS #
Show a => Show (Maybe a)	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> Maybe a -> ShowS # show :: Maybe a -> String # showList :: [Maybe a] -> ShowS #
Show a => Show (a)	Since: base-4.15
Instance details Defined in GHC.Show Methods showsPrec :: Int -> (a) -> ShowS # show :: (a) -> String # showList :: [(a)] -> ShowS #
Show a => Show [a]	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> [a] -> ShowS # show :: [a] -> String # showList :: [[a]] -> ShowS #
(Show a, Show b) => Show (a :-> b)
Instance details Defined in Test.QuickCheck.Function Methods showsPrec :: Int -> (a :-> b) -> ShowS # show :: (a :-> b) -> String # showList :: [a :-> b] -> ShowS #
(Show a, Show b) => Show (Fun a b)
Instance details Defined in Test.QuickCheck.Function Methods showsPrec :: Int -> Fun a b -> ShowS # show :: Fun a b -> String # showList :: [Fun a b] -> ShowS #
Show a => Show (Shrinking s a)
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> Shrinking s a -> ShowS # show :: Shrinking s a -> String # showList :: [Shrinking s a] -> ShowS #
(Show a, Show b) => Show (Either a b)	Since: base-3.0
Instance details Defined in Data.Either Methods showsPrec :: Int -> Either a b -> ShowS # show :: Either a b -> String # showList :: [Either a b] -> ShowS #
Show (Proxy s)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods showsPrec :: Int -> Proxy s -> ShowS # show :: Proxy s -> String # showList :: [Proxy s] -> ShowS #
Show (TypeRep a)
Instance details Defined in Data.Typeable.Internal Methods showsPrec :: Int -> TypeRep a -> ShowS # show :: TypeRep a -> String # showList :: [TypeRep a] -> ShowS #
Show (U1 p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> U1 p -> ShowS # show :: U1 p -> String # showList :: [U1 p] -> ShowS #
Show (V1 p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> V1 p -> ShowS # show :: V1 p -> String # showList :: [V1 p] -> ShowS #
Show (ST s a)	Since: base-2.1
Instance details Defined in GHC.ST Methods showsPrec :: Int -> ST s a -> ShowS # show :: ST s a -> String # showList :: [ST s a] -> ShowS #
(Show k, Show a) => Show (Map k a)
Instance details Defined in Data.Map.Internal Methods showsPrec :: Int -> Map k a -> ShowS # show :: Map k a -> String # showList :: [Map k a] -> ShowS #
(Show a, Unbox a) => Show (Tuple dim a)
Instance details Defined in Raaz.Core.Types.Tuple Methods showsPrec :: Int -> Tuple dim a -> ShowS # show :: Tuple dim a -> String # showList :: [Tuple dim a] -> ShowS #
(Show a, Show b) => Show (a, b)	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> (a, b) -> ShowS # show :: (a, b) -> String # showList :: [(a, b)] -> ShowS #
Show a => Show (Const a b)	This instance would be equivalent to the derived instances of the `Const` newtype if the `getConst` field were removed Since: base-4.8.0.0
Instance details Defined in Data.Functor.Const Methods showsPrec :: Int -> Const a b -> ShowS # show :: Const a b -> String # showList :: [Const a b] -> ShowS #
Show (f p) => Show (Rec1 f p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> Rec1 f p -> ShowS # show :: Rec1 f p -> String # showList :: [Rec1 f p] -> ShowS #
Show (URec Char p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Char p -> ShowS # show :: URec Char p -> String # showList :: [URec Char p] -> ShowS #
Show (URec Double p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Double p -> ShowS # show :: URec Double p -> String # showList :: [URec Double p] -> ShowS #
Show (URec Float p)
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Float p -> ShowS # show :: URec Float p -> String # showList :: [URec Float p] -> ShowS #
Show (URec Int p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Int p -> ShowS # show :: URec Int p -> String # showList :: [URec Int p] -> ShowS #
Show (URec Word p)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Word p -> ShowS # show :: URec Word p -> String # showList :: [URec Word p] -> ShowS #
Show a => Show (Constant a b)
Instance details Defined in Data.Functor.Constant Methods showsPrec :: Int -> Constant a b -> ShowS # show :: Constant a b -> String # showList :: [Constant a b] -> ShowS #
(Show a, Show b, Show c) => Show (a, b, c)	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> (a, b, c) -> ShowS # show :: (a, b, c) -> String # showList :: [(a, b, c)] -> ShowS #
(Show (f p), Show (g p)) => Show ((f :*: g) p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> (f :: g) p -> ShowS # show :: (f :: g) p -> String # showList :: [(f :*: g) p] -> ShowS #
(Show (f p), Show (g p)) => Show ((f :+: g) p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> (f :+: g) p -> ShowS # show :: (f :+: g) p -> String # showList :: [(f :+: g) p] -> ShowS #
Show c => Show (K1 i c p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> K1 i c p -> ShowS # show :: K1 i c p -> String # showList :: [K1 i c p] -> ShowS #
(Show a, Show b, Show c, Show d) => Show (a, b, c, d)	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> (a, b, c, d) -> ShowS # show :: (a, b, c, d) -> String # showList :: [(a, b, c, d)] -> ShowS #
Show (f (g p)) => Show ((f :.: g) p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> (f :.: g) p -> ShowS # show :: (f :.: g) p -> String # showList :: [(f :.: g) p] -> ShowS #
Show (f p) => Show (M1 i c f p)	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> M1 i c f p -> ShowS # show :: M1 i c f p -> String # showList :: [M1 i c f p] -> ShowS #
(Show a, Show b, Show c, Show d, Show e) => Show (a, b, c, d, e)	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> (a, b, c, d, e) -> ShowS # show :: (a, b, c, d, e) -> String # showList :: [(a, b, c, d, e)] -> ShowS #
(Show a, Show b, Show c, Show d, Show e, Show f) => Show (a, b, c, d, e, f)	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> (a, b, c, d, e, f) -> ShowS # show :: (a, b, c, d, e, f) -> String # showList :: [(a, b, c, d, e, f)] -> ShowS #
(Show a, Show b, Show c, Show d, Show e, Show f, Show g) => Show (a, b, c, d, e, f, g)	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> (a, b, c, d, e, f, g) -> ShowS # show :: (a, b, c, d, e, f, g) -> String # showList :: [(a, b, c, d, e, f, g)] -> ShowS #
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h) => Show (a, b, c, d, e, f, g, h)	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> (a, b, c, d, e, f, g, h) -> ShowS # show :: (a, b, c, d, e, f, g, h) -> String # showList :: [(a, b, c, d, e, f, g, h)] -> ShowS #
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i) => Show (a, b, c, d, e, f, g, h, i)	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> (a, b, c, d, e, f, g, h, i) -> ShowS # show :: (a, b, c, d, e, f, g, h, i) -> String # showList :: [(a, b, c, d, e, f, g, h, i)] -> ShowS #
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j) => Show (a, b, c, d, e, f, g, h, i, j)	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j) -> ShowS # show :: (a, b, c, d, e, f, g, h, i, j) -> String # showList :: [(a, b, c, d, e, f, g, h, i, j)] -> ShowS #
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k) => Show (a, b, c, d, e, f, g, h, i, j, k)	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k) -> ShowS # show :: (a, b, c, d, e, f, g, h, i, j, k) -> String # showList :: [(a, b, c, d, e, f, g, h, i, j, k)] -> ShowS #
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l) => Show (a, b, c, d, e, f, g, h, i, j, k, l)	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k, l) -> ShowS # show :: (a, b, c, d, e, f, g, h, i, j, k, l) -> String # showList :: [(a, b, c, d, e, f, g, h, i, j, k, l)] -> ShowS #
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m) => Show (a, b, c, d, e, f, g, h, i, j, k, l, m)	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> ShowS # show :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> String # showList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m)] -> ShowS #
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m, Show n) => Show (a, b, c, d, e, f, g, h, i, j, k, l, m, n)	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> ShowS # show :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> String # showList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)] -> ShowS #
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m, Show n, Show o) => Show (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)	Since: base-2.1
Instance details Defined in GHC.Show Methods showsPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> ShowS # show :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> String # showList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)] -> ShowS #

class Semigroup a => Monoid a where #

The class of monoids (types with an associative binary operation that has an identity). Instances should satisfy the following:

Right identity: x <> mempty = x
Left identity: mempty <> x = x
Associativity: x <> (y <> z) = (x <> y) <> z (Semigroup law)
Concatenation: mconcat = foldr (<>) mempty

You can alternatively define mconcat instead of mempty, in which case the laws are:

Unit: mconcat (pure x) = x
Multiplication: mconcat (join xss) = mconcat (fmap mconcat xss)
Subclass: mconcat (toList xs) = sconcat xs

The method names refer to the monoid of lists under concatenation, but there are many other instances.

Some types can be viewed as a monoid in more than one way, e.g. both addition and multiplication on numbers. In such cases we often define newtypes and make those instances of Monoid, e.g. Sum and Product.

NOTE: Semigroup is a superclass of Monoid since base-4.11.0.0.

Minimal complete definition

mempty | mconcat

Methods

mempty :: a #

Identity of mappend

>>> "Hello world" <> mempty
"Hello world"

mappend :: a -> a -> a #

An associative operation

NOTE: This method is redundant and has the default implementation mappend = (<>) since base-4.11.0.0. Should it be implemented manually, since mappend is a synonym for (<>), it is expected that the two functions are defined the same way. In a future GHC release mappend will be removed from Monoid.

mconcat :: [a] -> a #

Fold a list using the monoid.

For most types, the default definition for mconcat will be used, but the function is included in the class definition so that an optimized version can be provided for specific types.

>>> mconcat ["Hello", " ", "Haskell", "!"]
"Hello Haskell!"

Instances

Instances details

Monoid ByteString
Instance details Defined in Data.ByteString.Internal.Type Methods mempty :: ByteString # mappend :: ByteString -> ByteString -> ByteString # mconcat :: [ByteString] -> ByteString #
Monoid ShortByteString
Instance details Defined in Data.ByteString.Short.Internal Methods mempty :: ShortByteString # mappend :: ShortByteString -> ShortByteString -> ShortByteString # mconcat :: [ShortByteString] -> ShortByteString #
Monoid IntSet
Instance details Defined in Data.IntSet.Internal Methods mempty :: IntSet # mappend :: IntSet -> IntSet -> IntSet # mconcat :: [IntSet] -> IntSet #
Monoid OsString	"String-Concatenation" for `OsString`. This is not the same as `(</>)`.
Instance details Defined in System.OsString.Internal.Types Methods mempty :: OsString # mappend :: OsString -> OsString -> OsString # mconcat :: [OsString] -> OsString #
Monoid PosixString
Instance details Defined in System.OsString.Internal.Types Methods mempty :: PosixString # mappend :: PosixString -> PosixString -> PosixString # mconcat :: [PosixString] -> PosixString #
Monoid WindowsString
Instance details Defined in System.OsString.Internal.Types Methods mempty :: WindowsString # mappend :: WindowsString -> WindowsString -> WindowsString # mconcat :: [WindowsString] -> WindowsString #
Monoid Ordering	Since: base-2.1
Instance details Defined in GHC.Base Methods mempty :: Ordering # mappend :: Ordering -> Ordering -> Ordering # mconcat :: [Ordering] -> Ordering #
Monoid Doc
Instance details Defined in Text.PrettyPrint.HughesPJ Methods mempty :: Doc # mappend :: Doc -> Doc -> Doc # mconcat :: [Doc] -> Doc #
Monoid Base16
Instance details Defined in Raaz.Core.Encode.Base16 Methods mempty :: Base16 # mappend :: Base16 -> Base16 -> Base16 # mconcat :: [Base16] -> Base16 #
Monoid Base64
Instance details Defined in Raaz.Core.Encode.Base64 Methods mempty :: Base64 # mappend :: Base64 -> Base64 -> Base64 # mconcat :: [Base64] -> Base64 #
Monoid Result
Instance details Defined in Raaz.Core.Types.Equality Methods mempty :: Result # mappend :: Result -> Result -> Result # mconcat :: [Result] -> Result #
Monoid Alignment
Instance details Defined in Raaz.Core.Types.Pointer Methods mempty :: Alignment # mappend :: Alignment -> Alignment -> Alignment # mconcat :: [Alignment] -> Alignment #
Monoid ()	Since: base-2.1
Instance details Defined in GHC.Base Methods mempty :: () # mappend :: () -> () -> () # mconcat :: [()] -> () #
FiniteBits a => Monoid (And a)	This constraint is arguably too strong. However, as some types (such as `Natural`) have undefined `complement`, this is the only safe choice. Since: base-4.16
Instance details Defined in Data.Bits Methods mempty :: And a # mappend :: And a -> And a -> And a # mconcat :: [And a] -> And a #
FiniteBits a => Monoid (Iff a)	This constraint is arguably too strong. However, as some types (such as `Natural`) have undefined `complement`, this is the only safe choice. Since: base-4.16
Instance details Defined in Data.Bits Methods mempty :: Iff a # mappend :: Iff a -> Iff a -> Iff a # mconcat :: [Iff a] -> Iff a #
Bits a => Monoid (Ior a)	Since: base-4.16
Instance details Defined in Data.Bits Methods mempty :: Ior a # mappend :: Ior a -> Ior a -> Ior a # mconcat :: [Ior a] -> Ior a #
Bits a => Monoid (Xor a)	Since: base-4.16
Instance details Defined in Data.Bits Methods mempty :: Xor a # mappend :: Xor a -> Xor a -> Xor a # mconcat :: [Xor a] -> Xor a #
(Generic a, Monoid (Rep a ())) => Monoid (Generically a)	Since: base-4.17.0.0
Instance details Defined in GHC.Generics Methods mempty :: Generically a # mappend :: Generically a -> Generically a -> Generically a # mconcat :: [Generically a] -> Generically a #
Monoid p => Monoid (Par1 p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods mempty :: Par1 p # mappend :: Par1 p -> Par1 p -> Par1 p # mconcat :: [Par1 p] -> Par1 p #
Monoid (IntMap a)
Instance details Defined in Data.IntMap.Internal Methods mempty :: IntMap a # mappend :: IntMap a -> IntMap a -> IntMap a # mconcat :: [IntMap a] -> IntMap a #
Monoid (Seq a)
Instance details Defined in Data.Sequence.Internal Methods mempty :: Seq a # mappend :: Seq a -> Seq a -> Seq a # mconcat :: [Seq a] -> Seq a #
Monoid (MergeSet a)
Instance details Defined in Data.Set.Internal Methods mempty :: MergeSet a # mappend :: MergeSet a -> MergeSet a -> MergeSet a # mconcat :: [MergeSet a] -> MergeSet a #
Ord a => Monoid (Set a)
Instance details Defined in Data.Set.Internal Methods mempty :: Set a # mappend :: Set a -> Set a -> Set a # mconcat :: [Set a] -> Set a #
Monoid a => Monoid (IO a)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods mempty :: IO a # mappend :: IO a -> IO a -> IO a # mconcat :: [IO a] -> IO a #
Monoid (Doc a)
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods mempty :: Doc a # mappend :: Doc a -> Doc a -> Doc a # mconcat :: [Doc a] -> Doc a #
Monoid (Array a)
Instance details Defined in Data.Primitive.Array Methods mempty :: Array a # mappend :: Array a -> Array a -> Array a # mconcat :: [Array a] -> Array a #
Monoid (PrimArray a)	Since: primitive-0.6.4.0
Instance details Defined in Data.Primitive.PrimArray Methods mempty :: PrimArray a # mappend :: PrimArray a -> PrimArray a -> PrimArray a # mconcat :: [PrimArray a] -> PrimArray a #
Monoid (SmallArray a)
Instance details Defined in Data.Primitive.SmallArray Methods mempty :: SmallArray a # mappend :: SmallArray a -> SmallArray a -> SmallArray a # mconcat :: [SmallArray a] -> SmallArray a #
Monoid (BlockCount p)
Instance details Defined in Raaz.Core.Primitive Methods mempty :: BlockCount p # mappend :: BlockCount p -> BlockCount p -> BlockCount p # mconcat :: [BlockCount p] -> BlockCount p #
Monoid (TransferM t)
Instance details Defined in Raaz.Core.Transfer.Unsafe Methods mempty :: TransferM t # mappend :: TransferM t -> TransferM t -> TransferM t # mconcat :: [TransferM t] -> TransferM t #
Num a => Monoid (BYTES a)
Instance details Defined in Raaz.Core.Types.Pointer Methods mempty :: BYTES a # mappend :: BYTES a -> BYTES a -> BYTES a # mconcat :: [BYTES a] -> BYTES a #
Monoid a => Monoid (Q a)	Since: template-haskell-2.17.0.0
Instance details Defined in Language.Haskell.TH.Syntax Methods mempty :: Q a # mappend :: Q a -> Q a -> Q a # mconcat :: [Q a] -> Q a #
Prim a => Monoid (Vector a)
Instance details Defined in Data.Vector.Primitive Methods mempty :: Vector a # mappend :: Vector a -> Vector a -> Vector a # mconcat :: [Vector a] -> Vector a #
Semigroup a => Monoid (Maybe a)	Lift a semigroup into `Maybe` forming a `Monoid` according to http://en.wikipedia.org/wiki/Monoid: "Any semigroup `S` may be turned into a monoid simply by adjoining an element `e` not in `S` and defining `ee = e` and `es = s = se` for all `s ∈ S`." Since 4.11.0: constraint on inner `a` value generalised from `Monoid` to `Semigroup`. Since: base-2.1*
Instance details Defined in GHC.Base Methods mempty :: Maybe a # mappend :: Maybe a -> Maybe a -> Maybe a # mconcat :: [Maybe a] -> Maybe a #
Monoid a => Monoid (a)	Since: base-4.15
Instance details Defined in GHC.Base Methods mempty :: (a) # mappend :: (a) -> (a) -> (a) # mconcat :: [(a)] -> (a) #
Monoid [a]	Since: base-2.1
Instance details Defined in GHC.Base Methods mempty :: [a] # mappend :: [a] -> [a] -> [a] # mconcat :: [[a]] -> [a] #
Monoid (Proxy s)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods mempty :: Proxy s # mappend :: Proxy s -> Proxy s -> Proxy s # mconcat :: [Proxy s] -> Proxy s #
Monoid (U1 p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods mempty :: U1 p # mappend :: U1 p -> U1 p -> U1 p # mconcat :: [U1 p] -> U1 p #
Monoid a => Monoid (ST s a)	Since: base-4.11.0.0
Instance details Defined in GHC.ST Methods mempty :: ST s a # mappend :: ST s a -> ST s a -> ST s a # mconcat :: [ST s a] -> ST s a #
Ord k => Monoid (Map k v)
Instance details Defined in Data.Map.Internal Methods mempty :: Map k v # mappend :: Map k v -> Map k v -> Map k v # mconcat :: [Map k v] -> Map k v #
(Monoid a, Monoid b) => Monoid (a, b)	Since: base-2.1
Instance details Defined in GHC.Base Methods mempty :: (a, b) # mappend :: (a, b) -> (a, b) -> (a, b) # mconcat :: [(a, b)] -> (a, b) #
Monoid b => Monoid (a -> b)	Since: base-2.1
Instance details Defined in GHC.Base Methods mempty :: a -> b # mappend :: (a -> b) -> (a -> b) -> a -> b # mconcat :: [a -> b] -> a -> b #
Monoid a => Monoid (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods mempty :: Const a b # mappend :: Const a b -> Const a b -> Const a b # mconcat :: [Const a b] -> Const a b #
Monoid (f p) => Monoid (Rec1 f p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods mempty :: Rec1 f p # mappend :: Rec1 f p -> Rec1 f p -> Rec1 f p # mconcat :: [Rec1 f p] -> Rec1 f p #
Monoid a => Monoid (Constant a b)
Instance details Defined in Data.Functor.Constant Methods mempty :: Constant a b # mappend :: Constant a b -> Constant a b -> Constant a b # mconcat :: [Constant a b] -> Constant a b #
(Monoid a, Monoid b, Monoid c) => Monoid (a, b, c)	Since: base-2.1
Instance details Defined in GHC.Base Methods mempty :: (a, b, c) # mappend :: (a, b, c) -> (a, b, c) -> (a, b, c) # mconcat :: [(a, b, c)] -> (a, b, c) #
(Monoid (f p), Monoid (g p)) => Monoid ((f :*: g) p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods mempty :: (f :: g) p # mappend :: (f :: g) p -> (f :: g) p -> (f :: g) p # mconcat :: [(f :: g) p] -> (f :: g) p #
Monoid c => Monoid (K1 i c p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods mempty :: K1 i c p # mappend :: K1 i c p -> K1 i c p -> K1 i c p # mconcat :: [K1 i c p] -> K1 i c p #
(Monoid a, Monoid b, Monoid c, Monoid d) => Monoid (a, b, c, d)	Since: base-2.1
Instance details Defined in GHC.Base Methods mempty :: (a, b, c, d) # mappend :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d) # mconcat :: [(a, b, c, d)] -> (a, b, c, d) #
Monoid (f (g p)) => Monoid ((f :.: g) p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods mempty :: (f :.: g) p # mappend :: (f :.: g) p -> (f :.: g) p -> (f :.: g) p # mconcat :: [(f :.: g) p] -> (f :.: g) p #
Monoid (f p) => Monoid (M1 i c f p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods mempty :: M1 i c f p # mappend :: M1 i c f p -> M1 i c f p -> M1 i c f p # mconcat :: [M1 i c f p] -> M1 i c f p #
(Monoid a, Monoid b, Monoid c, Monoid d, Monoid e) => Monoid (a, b, c, d, e)	Since: base-2.1
Instance details Defined in GHC.Base Methods mempty :: (a, b, c, d, e) # mappend :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) # mconcat :: [(a, b, c, d, e)] -> (a, b, c, d, e) #

class Semigroup a where #

The class of semigroups (types with an associative binary operation).

Instances should satisfy the following:

Associativity: x <> (y <> z) = (x <> y) <> z

You can alternatively define sconcat instead of (<>), in which case the laws are:

Unit: sconcat (pure x) = x
Multiplication: sconcat (join xss) = sconcat (fmap sconcat xss)

Since: base-4.9.0.0

Minimal complete definition

(<>) | sconcat

Methods

(<>) :: a -> a -> a infixr 6 #

An associative operation.

>>> [1,2,3] <> [4,5,6]
[1,2,3,4,5,6]

Instances

Instances details

Semigroup Void	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (<>) :: Void -> Void -> Void # sconcat :: NonEmpty Void -> Void # stimes :: Integral b => b -> Void -> Void #
Semigroup ByteString
Instance details Defined in Data.ByteString.Internal.Type Methods (<>) :: ByteString -> ByteString -> ByteString # sconcat :: NonEmpty ByteString -> ByteString # stimes :: Integral b => b -> ByteString -> ByteString #
Semigroup ShortByteString
Instance details Defined in Data.ByteString.Short.Internal Methods (<>) :: ShortByteString -> ShortByteString -> ShortByteString # sconcat :: NonEmpty ShortByteString -> ShortByteString # stimes :: Integral b => b -> ShortByteString -> ShortByteString #
Semigroup IntSet	Since: containers-0.5.7
Instance details Defined in Data.IntSet.Internal Methods (<>) :: IntSet -> IntSet -> IntSet # sconcat :: NonEmpty IntSet -> IntSet # stimes :: Integral b => b -> IntSet -> IntSet #
Semigroup OsString
Instance details Defined in System.OsString.Internal.Types Methods (<>) :: OsString -> OsString -> OsString # sconcat :: NonEmpty OsString -> OsString # stimes :: Integral b => b -> OsString -> OsString #
Semigroup PosixString
Instance details Defined in System.OsString.Internal.Types Methods (<>) :: PosixString -> PosixString -> PosixString # sconcat :: NonEmpty PosixString -> PosixString # stimes :: Integral b => b -> PosixString -> PosixString #
Semigroup WindowsString
Instance details Defined in System.OsString.Internal.Types Methods (<>) :: WindowsString -> WindowsString -> WindowsString # sconcat :: NonEmpty WindowsString -> WindowsString # stimes :: Integral b => b -> WindowsString -> WindowsString #
Semigroup Ordering	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (<>) :: Ordering -> Ordering -> Ordering # sconcat :: NonEmpty Ordering -> Ordering # stimes :: Integral b => b -> Ordering -> Ordering #
Semigroup Doc
Instance details Defined in Text.PrettyPrint.HughesPJ Methods (<>) :: Doc -> Doc -> Doc # sconcat :: NonEmpty Doc -> Doc # stimes :: Integral b => b -> Doc -> Doc #
Semigroup Base16
Instance details Defined in Raaz.Core.Encode.Base16 Methods (<>) :: Base16 -> Base16 -> Base16 # sconcat :: NonEmpty Base16 -> Base16 # stimes :: Integral b => b -> Base16 -> Base16 #
Semigroup Base64
Instance details Defined in Raaz.Core.Encode.Base64 Methods (<>) :: Base64 -> Base64 -> Base64 # sconcat :: NonEmpty Base64 -> Base64 # stimes :: Integral b => b -> Base64 -> Base64 #
Semigroup Result
Instance details Defined in Raaz.Core.Types.Equality Methods (<>) :: Result -> Result -> Result # sconcat :: NonEmpty Result -> Result # stimes :: Integral b => b -> Result -> Result #
Semigroup Alignment
Instance details Defined in Raaz.Core.Types.Pointer Methods (<>) :: Alignment -> Alignment -> Alignment # sconcat :: NonEmpty Alignment -> Alignment # stimes :: Integral b => b -> Alignment -> Alignment #
Semigroup ()	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (<>) :: () -> () -> () # sconcat :: NonEmpty () -> () # stimes :: Integral b => b -> () -> () #
Bits a => Semigroup (And a)	Since: base-4.16
Instance details Defined in Data.Bits Methods (<>) :: And a -> And a -> And a # sconcat :: NonEmpty (And a) -> And a # stimes :: Integral b => b -> And a -> And a #
FiniteBits a => Semigroup (Iff a)	This constraint is arguably too strong. However, as some types (such as `Natural`) have undefined `complement`, this is the only safe choice. Since: base-4.16
Instance details Defined in Data.Bits Methods (<>) :: Iff a -> Iff a -> Iff a # sconcat :: NonEmpty (Iff a) -> Iff a # stimes :: Integral b => b -> Iff a -> Iff a #
Bits a => Semigroup (Ior a)	Since: base-4.16
Instance details Defined in Data.Bits Methods (<>) :: Ior a -> Ior a -> Ior a # sconcat :: NonEmpty (Ior a) -> Ior a # stimes :: Integral b => b -> Ior a -> Ior a #
Bits a => Semigroup (Xor a)	Since: base-4.16
Instance details Defined in Data.Bits Methods (<>) :: Xor a -> Xor a -> Xor a # sconcat :: NonEmpty (Xor a) -> Xor a # stimes :: Integral b => b -> Xor a -> Xor a #
Semigroup (NonEmpty a)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (<>) :: NonEmpty a -> NonEmpty a -> NonEmpty a # sconcat :: NonEmpty (NonEmpty a) -> NonEmpty a # stimes :: Integral b => b -> NonEmpty a -> NonEmpty a #
(Generic a, Semigroup (Rep a ())) => Semigroup (Generically a)	Since: base-4.17.0.0
Instance details Defined in GHC.Generics Methods (<>) :: Generically a -> Generically a -> Generically a # sconcat :: NonEmpty (Generically a) -> Generically a # stimes :: Integral b => b -> Generically a -> Generically a #
Semigroup p => Semigroup (Par1 p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods (<>) :: Par1 p -> Par1 p -> Par1 p # sconcat :: NonEmpty (Par1 p) -> Par1 p # stimes :: Integral b => b -> Par1 p -> Par1 p #
Semigroup (IntMap a)	Since: containers-0.5.7
Instance details Defined in Data.IntMap.Internal Methods (<>) :: IntMap a -> IntMap a -> IntMap a # sconcat :: NonEmpty (IntMap a) -> IntMap a # stimes :: Integral b => b -> IntMap a -> IntMap a #
Semigroup (Seq a)	Since: containers-0.5.7
Instance details Defined in Data.Sequence.Internal Methods (<>) :: Seq a -> Seq a -> Seq a # sconcat :: NonEmpty (Seq a) -> Seq a # stimes :: Integral b => b -> Seq a -> Seq a #
Ord a => Semigroup (Intersection a)
Instance details Defined in Data.Set.Internal Methods (<>) :: Intersection a -> Intersection a -> Intersection a # sconcat :: NonEmpty (Intersection a) -> Intersection a # stimes :: Integral b => b -> Intersection a -> Intersection a #
Semigroup (MergeSet a)
Instance details Defined in Data.Set.Internal Methods (<>) :: MergeSet a -> MergeSet a -> MergeSet a # sconcat :: NonEmpty (MergeSet a) -> MergeSet a # stimes :: Integral b => b -> MergeSet a -> MergeSet a #
Ord a => Semigroup (Set a)	Since: containers-0.5.7
Instance details Defined in Data.Set.Internal Methods (<>) :: Set a -> Set a -> Set a # sconcat :: NonEmpty (Set a) -> Set a # stimes :: Integral b => b -> Set a -> Set a #
Semigroup a => Semigroup (IO a)	Since: base-4.10.0.0
Instance details Defined in GHC.Base Methods (<>) :: IO a -> IO a -> IO a # sconcat :: NonEmpty (IO a) -> IO a # stimes :: Integral b => b -> IO a -> IO a #
Semigroup (Doc a)
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods (<>) :: Doc a -> Doc a -> Doc a # sconcat :: NonEmpty (Doc a) -> Doc a # stimes :: Integral b => b -> Doc a -> Doc a #
Semigroup (Array a)	Since: primitive-0.6.3.0
Instance details Defined in Data.Primitive.Array Methods (<>) :: Array a -> Array a -> Array a # sconcat :: NonEmpty (Array a) -> Array a # stimes :: Integral b => b -> Array a -> Array a #
Semigroup (PrimArray a)	Since: primitive-0.6.4.0
Instance details Defined in Data.Primitive.PrimArray Methods (<>) :: PrimArray a -> PrimArray a -> PrimArray a # sconcat :: NonEmpty (PrimArray a) -> PrimArray a # stimes :: Integral b => b -> PrimArray a -> PrimArray a #
Semigroup (SmallArray a)	Since: primitive-0.6.3.0
Instance details Defined in Data.Primitive.SmallArray Methods (<>) :: SmallArray a -> SmallArray a -> SmallArray a # sconcat :: NonEmpty (SmallArray a) -> SmallArray a # stimes :: Integral b => b -> SmallArray a -> SmallArray a #
Semigroup (BlockCount p)
Instance details Defined in Raaz.Core.Primitive Methods (<>) :: BlockCount p -> BlockCount p -> BlockCount p # sconcat :: NonEmpty (BlockCount p) -> BlockCount p # stimes :: Integral b => b -> BlockCount p -> BlockCount p #
Semigroup (TransferM t)
Instance details Defined in Raaz.Core.Transfer.Unsafe Methods (<>) :: TransferM t -> TransferM t -> TransferM t # sconcat :: NonEmpty (TransferM t) -> TransferM t # stimes :: Integral b => b -> TransferM t -> TransferM t #
Num a => Semigroup (BYTES a)
Instance details Defined in Raaz.Core.Types.Pointer Methods (<>) :: BYTES a -> BYTES a -> BYTES a # sconcat :: NonEmpty (BYTES a) -> BYTES a # stimes :: Integral b => b -> BYTES a -> BYTES a #
Semigroup a => Semigroup (Q a)	Since: template-haskell-2.17.0.0
Instance details Defined in Language.Haskell.TH.Syntax Methods (<>) :: Q a -> Q a -> Q a # sconcat :: NonEmpty (Q a) -> Q a # stimes :: Integral b => b -> Q a -> Q a #
Prim a => Semigroup (Vector a)
Instance details Defined in Data.Vector.Primitive Methods (<>) :: Vector a -> Vector a -> Vector a # sconcat :: NonEmpty (Vector a) -> Vector a # stimes :: Integral b => b -> Vector a -> Vector a #
Semigroup a => Semigroup (Maybe a)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (<>) :: Maybe a -> Maybe a -> Maybe a # sconcat :: NonEmpty (Maybe a) -> Maybe a # stimes :: Integral b => b -> Maybe a -> Maybe a #
Semigroup a => Semigroup (a)	Since: base-4.15
Instance details Defined in GHC.Base Methods (<>) :: (a) -> (a) -> (a) # sconcat :: NonEmpty (a) -> (a) # stimes :: Integral b => b -> (a) -> (a) #
Semigroup [a]	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (<>) :: [a] -> [a] -> [a] # sconcat :: NonEmpty [a] -> [a] # stimes :: Integral b => b -> [a] -> [a] #
Semigroup (Either a b)	Since: base-4.9.0.0
Instance details Defined in Data.Either Methods (<>) :: Either a b -> Either a b -> Either a b # sconcat :: NonEmpty (Either a b) -> Either a b # stimes :: Integral b0 => b0 -> Either a b -> Either a b #
Semigroup (Proxy s)	Since: base-4.9.0.0
Instance details Defined in Data.Proxy Methods (<>) :: Proxy s -> Proxy s -> Proxy s # sconcat :: NonEmpty (Proxy s) -> Proxy s # stimes :: Integral b => b -> Proxy s -> Proxy s #
Semigroup (U1 p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods (<>) :: U1 p -> U1 p -> U1 p # sconcat :: NonEmpty (U1 p) -> U1 p # stimes :: Integral b => b -> U1 p -> U1 p #
Semigroup (V1 p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods (<>) :: V1 p -> V1 p -> V1 p # sconcat :: NonEmpty (V1 p) -> V1 p # stimes :: Integral b => b -> V1 p -> V1 p #
Semigroup a => Semigroup (ST s a)	Since: base-4.11.0.0
Instance details Defined in GHC.ST Methods (<>) :: ST s a -> ST s a -> ST s a # sconcat :: NonEmpty (ST s a) -> ST s a # stimes :: Integral b => b -> ST s a -> ST s a #
Ord k => Semigroup (Map k v)
Instance details Defined in Data.Map.Internal Methods (<>) :: Map k v -> Map k v -> Map k v # sconcat :: NonEmpty (Map k v) -> Map k v # stimes :: Integral b => b -> Map k v -> Map k v #
(Semigroup a, Semigroup b) => Semigroup (a, b)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (<>) :: (a, b) -> (a, b) -> (a, b) # sconcat :: NonEmpty (a, b) -> (a, b) # stimes :: Integral b0 => b0 -> (a, b) -> (a, b) #
Semigroup b => Semigroup (a -> b)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (<>) :: (a -> b) -> (a -> b) -> a -> b # sconcat :: NonEmpty (a -> b) -> a -> b # stimes :: Integral b0 => b0 -> (a -> b) -> a -> b #
Semigroup a => Semigroup (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods (<>) :: Const a b -> Const a b -> Const a b # sconcat :: NonEmpty (Const a b) -> Const a b # stimes :: Integral b0 => b0 -> Const a b -> Const a b #
Semigroup (f p) => Semigroup (Rec1 f p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods (<>) :: Rec1 f p -> Rec1 f p -> Rec1 f p # sconcat :: NonEmpty (Rec1 f p) -> Rec1 f p # stimes :: Integral b => b -> Rec1 f p -> Rec1 f p #
Semigroup a => Semigroup (Constant a b)
Instance details Defined in Data.Functor.Constant Methods (<>) :: Constant a b -> Constant a b -> Constant a b # sconcat :: NonEmpty (Constant a b) -> Constant a b # stimes :: Integral b0 => b0 -> Constant a b -> Constant a b #
(Semigroup a, Semigroup b, Semigroup c) => Semigroup (a, b, c)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (<>) :: (a, b, c) -> (a, b, c) -> (a, b, c) # sconcat :: NonEmpty (a, b, c) -> (a, b, c) # stimes :: Integral b0 => b0 -> (a, b, c) -> (a, b, c) #
(Semigroup (f p), Semigroup (g p)) => Semigroup ((f :*: g) p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods (<>) :: (f :: g) p -> (f :: g) p -> (f :: g) p # sconcat :: NonEmpty ((f :: g) p) -> (f :: g) p # stimes :: Integral b => b -> (f :: g) p -> (f :*: g) p #
Semigroup c => Semigroup (K1 i c p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods (<>) :: K1 i c p -> K1 i c p -> K1 i c p # sconcat :: NonEmpty (K1 i c p) -> K1 i c p # stimes :: Integral b => b -> K1 i c p -> K1 i c p #
(Semigroup a, Semigroup b, Semigroup c, Semigroup d) => Semigroup (a, b, c, d)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (<>) :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d) # sconcat :: NonEmpty (a, b, c, d) -> (a, b, c, d) # stimes :: Integral b0 => b0 -> (a, b, c, d) -> (a, b, c, d) #
Semigroup (f (g p)) => Semigroup ((f :.: g) p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods (<>) :: (f :.: g) p -> (f :.: g) p -> (f :.: g) p # sconcat :: NonEmpty ((f :.: g) p) -> (f :.: g) p # stimes :: Integral b => b -> (f :.: g) p -> (f :.: g) p #
Semigroup (f p) => Semigroup (M1 i c f p)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods (<>) :: M1 i c f p -> M1 i c f p -> M1 i c f p # sconcat :: NonEmpty (M1 i c f p) -> M1 i c f p # stimes :: Integral b => b -> M1 i c f p -> M1 i c f p #
(Semigroup a, Semigroup b, Semigroup c, Semigroup d, Semigroup e) => Semigroup (a, b, c, d, e)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (<>) :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) # sconcat :: NonEmpty (a, b, c, d, e) -> (a, b, c, d, e) # stimes :: Integral b0 => b0 -> (a, b, c, d, e) -> (a, b, c, d, e) #

class Functor f => Applicative (f :: Type -> Type) where #

A functor with application, providing operations to

embed pure expressions (pure), and
sequence computations and combine their results (<*> and liftA2).

A minimal complete definition must include implementations of pure and of either <*> or liftA2. If it defines both, then they must behave the same as their default definitions:

(<*>) = liftA2 id

liftA2 f x y = f <$> x <*> y

Further, any definition must satisfy the following:

Identity

pure id <*> v = v

Composition

pure (.) <*> u <*> v <*> w = u <*> (v <*> w)

Homomorphism

pure f <*> pure x = pure (f x)

Interchange

u <*> pure y = pure ($ y) <*> u

The other methods have the following default definitions, which may be overridden with equivalent specialized implementations:

```
u *> v = (id <$ u) <*> v
```
```
u <* v = liftA2 const u v
```

As a consequence of these laws, the Functor instance for f will satisfy

```
fmap f x = pure f <*> x
```

It may be useful to note that supposing

forall x y. p (q x y) = f x . g y

it follows from the above that

liftA2 p (liftA2 q u v) = liftA2 f u . liftA2 g v

If f is also a Monad, it should satisfy

```
pure = return
```

m1 <*> m2 = m1 >>= (\x1 -> m2 >>= (\x2 -> return (x1 x2)))

```
(*>) = (>>)
```

(which implies that pure and <*> satisfy the applicative functor laws).

Minimal complete definition

pure, ((<*>) | liftA2)

Methods

pure :: a -> f a #

Lift a value.

(<*>) :: f (a -> b) -> f a -> f b infixl 4 #

Sequential application.

A few functors support an implementation of <*> that is more efficient than the default one.

Example

Expand

Used in combination with (<$>), (<*>) can be used to build a record.

>>> data MyState = MyState {arg1 :: Foo, arg2 :: Bar, arg3 :: Baz}

>>> produceFoo :: Applicative f => f Foo

>>> produceBar :: Applicative f => f Bar
>>> produceBaz :: Applicative f => f Baz

>>> mkState :: Applicative f => f MyState
>>> mkState = MyState <$> produceFoo <*> produceBar <*> produceBaz

liftA2 :: (a -> b -> c) -> f a -> f b -> f c #

Lift a binary function to actions.

Some functors support an implementation of liftA2 that is more efficient than the default one. In particular, if fmap is an expensive operation, it is likely better to use liftA2 than to fmap over the structure and then use <*>.

This became a typeclass method in 4.10.0.0. Prior to that, it was a function defined in terms of <*> and fmap.

Example

Expand

>>> liftA2 (,) (Just 3) (Just 5)
Just (3,5)

(*>) :: f a -> f b -> f b infixl 4 #

Sequence actions, discarding the value of the first argument.

Examples

Expand

If used in conjunction with the Applicative instance for Maybe, you can chain Maybe computations, with a possible "early return" in case of Nothing.

>>> Just 2 *> Just 3
Just 3

>>> Nothing *> Just 3
Nothing

Of course a more interesting use case would be to have effectful computations instead of just returning pure values.

>>> import Data.Char
>>> import Text.ParserCombinators.ReadP
>>> let p = string "my name is " *> munch1 isAlpha <* eof
>>> readP_to_S p "my name is Simon"
[("Simon","")]

(<*) :: f a -> f b -> f a infixl 4 #

Sequence actions, discarding the value of the second argument.

Instances

Instances details

Applicative Gen
Instance details Defined in Test.QuickCheck.Gen Methods pure :: a -> Gen a # (<>) :: Gen (a -> b) -> Gen a -> Gen b # liftA2 :: (a -> b -> c) -> Gen a -> Gen b -> Gen c # (>) :: Gen a -> Gen b -> Gen b # (<*) :: Gen a -> Gen b -> Gen a #
Applicative Rose
Instance details Defined in Test.QuickCheck.Property Methods pure :: a -> Rose a # (<>) :: Rose (a -> b) -> Rose a -> Rose b # liftA2 :: (a -> b -> c) -> Rose a -> Rose b -> Rose c # (>) :: Rose a -> Rose b -> Rose b # (<*) :: Rose a -> Rose b -> Rose a #
Applicative ZipList	f <$> ZipList xs1 <> ... <> ZipList xsN = ZipList (zipWithN f xs1 ... xsN) where `zipWithN` refers to the `zipWith` function of the appropriate arity (`zipWith`, `zipWith3`, `zipWith4`, ...). For example: (\a b c -> stimes c [a, b]) <$> ZipList "abcd" <> ZipList "567" <> ZipList [1..] = ZipList (zipWith3 (\a b c -> stimes c [a, b]) "abcd" "567" [1..]) = ZipList {getZipList = ["a5","b6b6","c7c7c7"]} Since: base-2.1
Instance details Defined in Control.Applicative Methods pure :: a -> ZipList a # (<>) :: ZipList (a -> b) -> ZipList a -> ZipList b # liftA2 :: (a -> b -> c) -> ZipList a -> ZipList b -> ZipList c # (>) :: ZipList a -> ZipList b -> ZipList b # (<*) :: ZipList a -> ZipList b -> ZipList a #
Applicative NonEmpty	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods pure :: a -> NonEmpty a # (<>) :: NonEmpty (a -> b) -> NonEmpty a -> NonEmpty b # liftA2 :: (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c # (>) :: NonEmpty a -> NonEmpty b -> NonEmpty b # (<*) :: NonEmpty a -> NonEmpty b -> NonEmpty a #
Applicative Par1	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods pure :: a -> Par1 a # (<>) :: Par1 (a -> b) -> Par1 a -> Par1 b # liftA2 :: (a -> b -> c) -> Par1 a -> Par1 b -> Par1 c # (>) :: Par1 a -> Par1 b -> Par1 b # (<*) :: Par1 a -> Par1 b -> Par1 a #
Applicative P	Since: base-4.5.0.0
Instance details Defined in Text.ParserCombinators.ReadP Methods pure :: a -> P a # (<>) :: P (a -> b) -> P a -> P b # liftA2 :: (a -> b -> c) -> P a -> P b -> P c # (>) :: P a -> P b -> P b # (<*) :: P a -> P b -> P a #
Applicative ReadP	Since: base-4.6.0.0
Instance details Defined in Text.ParserCombinators.ReadP Methods pure :: a -> ReadP a # (<>) :: ReadP (a -> b) -> ReadP a -> ReadP b # liftA2 :: (a -> b -> c) -> ReadP a -> ReadP b -> ReadP c # (>) :: ReadP a -> ReadP b -> ReadP b # (<*) :: ReadP a -> ReadP b -> ReadP a #
Applicative Seq	Since: containers-0.5.4
Instance details Defined in Data.Sequence.Internal Methods pure :: a -> Seq a # (<>) :: Seq (a -> b) -> Seq a -> Seq b # liftA2 :: (a -> b -> c) -> Seq a -> Seq b -> Seq c # (>) :: Seq a -> Seq b -> Seq b # (<*) :: Seq a -> Seq b -> Seq a #
Applicative Tree
Instance details Defined in Data.Tree Methods pure :: a -> Tree a # (<>) :: Tree (a -> b) -> Tree a -> Tree b # liftA2 :: (a -> b -> c) -> Tree a -> Tree b -> Tree c # (>) :: Tree a -> Tree b -> Tree b # (<*) :: Tree a -> Tree b -> Tree a #
Applicative IO	Since: base-2.1
Instance details Defined in GHC.Base Methods pure :: a -> IO a # (<>) :: IO (a -> b) -> IO a -> IO b # liftA2 :: (a -> b -> c) -> IO a -> IO b -> IO c # (>) :: IO a -> IO b -> IO b # (<*) :: IO a -> IO b -> IO a #
Applicative Array
Instance details Defined in Data.Primitive.Array Methods pure :: a -> Array a # (<>) :: Array (a -> b) -> Array a -> Array b # liftA2 :: (a -> b -> c) -> Array a -> Array b -> Array c # (>) :: Array a -> Array b -> Array b # (<*) :: Array a -> Array b -> Array a #
Applicative SmallArray
Instance details Defined in Data.Primitive.SmallArray Methods pure :: a -> SmallArray a # (<>) :: SmallArray (a -> b) -> SmallArray a -> SmallArray b # liftA2 :: (a -> b -> c) -> SmallArray a -> SmallArray b -> SmallArray c # (>) :: SmallArray a -> SmallArray b -> SmallArray b # (<*) :: SmallArray a -> SmallArray b -> SmallArray a #
Applicative Q
Instance details Defined in Language.Haskell.TH.Syntax Methods pure :: a -> Q a # (<>) :: Q (a -> b) -> Q a -> Q b # liftA2 :: (a -> b -> c) -> Q a -> Q b -> Q c # (>) :: Q a -> Q b -> Q b # (<*) :: Q a -> Q b -> Q a #
Applicative Maybe	Since: base-2.1
Instance details Defined in GHC.Base Methods pure :: a -> Maybe a # (<>) :: Maybe (a -> b) -> Maybe a -> Maybe b # liftA2 :: (a -> b -> c) -> Maybe a -> Maybe b -> Maybe c # (>) :: Maybe a -> Maybe b -> Maybe b # (<*) :: Maybe a -> Maybe b -> Maybe a #
Applicative Solo	Since: base-4.15
Instance details Defined in GHC.Base Methods pure :: a -> Solo a # (<>) :: Solo (a -> b) -> Solo a -> Solo b # liftA2 :: (a -> b -> c) -> Solo a -> Solo b -> Solo c # (>) :: Solo a -> Solo b -> Solo b # (<*) :: Solo a -> Solo b -> Solo a #
Applicative List	Since: base-2.1
Instance details Defined in GHC.Base Methods pure :: a -> [a] # (<>) :: [a -> b] -> [a] -> [b] # liftA2 :: (a -> b -> c) -> [a] -> [b] -> [c] # (>) :: [a] -> [b] -> [b] # (<*) :: [a] -> [b] -> [a] #
Applicative (PropertyM m)
Instance details Defined in Test.QuickCheck.Monadic Methods pure :: a -> PropertyM m a # (<>) :: PropertyM m (a -> b) -> PropertyM m a -> PropertyM m b # liftA2 :: (a -> b -> c) -> PropertyM m a -> PropertyM m b -> PropertyM m c # (>) :: PropertyM m a -> PropertyM m b -> PropertyM m b # (<*) :: PropertyM m a -> PropertyM m b -> PropertyM m a #
Monad m => Applicative (WrappedMonad m)	Since: base-2.1
Instance details Defined in Control.Applicative Methods pure :: a -> WrappedMonad m a # (<>) :: WrappedMonad m (a -> b) -> WrappedMonad m a -> WrappedMonad m b # liftA2 :: (a -> b -> c) -> WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m c # (>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b # (<*) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m a #
Applicative (Either e)	Since: base-3.0
Instance details Defined in Data.Either Methods pure :: a -> Either e a # (<>) :: Either e (a -> b) -> Either e a -> Either e b # liftA2 :: (a -> b -> c) -> Either e a -> Either e b -> Either e c # (>) :: Either e a -> Either e b -> Either e b # (<*) :: Either e a -> Either e b -> Either e a #
Applicative (Proxy :: Type -> Type)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods pure :: a -> Proxy a # (<>) :: Proxy (a -> b) -> Proxy a -> Proxy b # liftA2 :: (a -> b -> c) -> Proxy a -> Proxy b -> Proxy c # (>) :: Proxy a -> Proxy b -> Proxy b # (<*) :: Proxy a -> Proxy b -> Proxy a #
Applicative (U1 :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods pure :: a -> U1 a # (<>) :: U1 (a -> b) -> U1 a -> U1 b # liftA2 :: (a -> b -> c) -> U1 a -> U1 b -> U1 c # (>) :: U1 a -> U1 b -> U1 b # (<*) :: U1 a -> U1 b -> U1 a #
Applicative (ST s)	Since: base-4.4.0.0
Instance details Defined in GHC.ST Methods pure :: a -> ST s a # (<>) :: ST s (a -> b) -> ST s a -> ST s b # liftA2 :: (a -> b -> c) -> ST s a -> ST s b -> ST s c # (>) :: ST s a -> ST s b -> ST s b # (<*) :: ST s a -> ST s b -> ST s a #
Applicative (SpecM a)
Instance details Defined in Test.Hspec.Core.Spec.Monad Methods pure :: a0 -> SpecM a a0 # (<>) :: SpecM a (a0 -> b) -> SpecM a a0 -> SpecM a b # liftA2 :: (a0 -> b -> c) -> SpecM a a0 -> SpecM a b -> SpecM a c # (>) :: SpecM a a0 -> SpecM a b -> SpecM a b # (<*) :: SpecM a a0 -> SpecM a b -> SpecM a a0 #
Monoid a => Applicative ((,) a)	For tuples, the `Monoid` constraint on `a` determines how the first values merge. For example, `String`s concatenate: ("hello ", (+15)) <> ("world!", 2002) ("hello world!",2017) Since: base-2.1*
Instance details Defined in GHC.Base Methods pure :: a0 -> (a, a0) # (<>) :: (a, a0 -> b) -> (a, a0) -> (a, b) # liftA2 :: (a0 -> b -> c) -> (a, a0) -> (a, b) -> (a, c) # (>) :: (a, a0) -> (a, b) -> (a, b) # (<*) :: (a, a0) -> (a, b) -> (a, a0) #
Arrow a => Applicative (WrappedArrow a b)	Since: base-2.1
Instance details Defined in Control.Applicative Methods pure :: a0 -> WrappedArrow a b a0 # (<>) :: WrappedArrow a b (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0 # liftA2 :: (a0 -> b0 -> c) -> WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b c # (>) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b b0 # (<*) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0 #
Monoid m => Applicative (Const m :: Type -> Type)	Since: base-2.0.1
Instance details Defined in Data.Functor.Const Methods pure :: a -> Const m a # (<>) :: Const m (a -> b) -> Const m a -> Const m b # liftA2 :: (a -> b -> c) -> Const m a -> Const m b -> Const m c # (>) :: Const m a -> Const m b -> Const m b # (<*) :: Const m a -> Const m b -> Const m a #
(Generic1 f, Applicative (Rep1 f)) => Applicative (Generically1 f)	Since: base-4.17.0.0
Instance details Defined in GHC.Generics Methods pure :: a -> Generically1 f a # (<>) :: Generically1 f (a -> b) -> Generically1 f a -> Generically1 f b # liftA2 :: (a -> b -> c) -> Generically1 f a -> Generically1 f b -> Generically1 f c # (>) :: Generically1 f a -> Generically1 f b -> Generically1 f b # (<*) :: Generically1 f a -> Generically1 f b -> Generically1 f a #
Applicative f => Applicative (Rec1 f)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods pure :: a -> Rec1 f a # (<>) :: Rec1 f (a -> b) -> Rec1 f a -> Rec1 f b # liftA2 :: (a -> b -> c) -> Rec1 f a -> Rec1 f b -> Rec1 f c # (>) :: Rec1 f a -> Rec1 f b -> Rec1 f b # (<*) :: Rec1 f a -> Rec1 f b -> Rec1 f a #
(Applicative f, Monad f) => Applicative (WhenMissing f x)	Equivalent to `ReaderT k (ReaderT x (MaybeT f))`. Since: containers-0.5.9
Instance details Defined in Data.IntMap.Internal Methods pure :: a -> WhenMissing f x a # (<>) :: WhenMissing f x (a -> b) -> WhenMissing f x a -> WhenMissing f x b # liftA2 :: (a -> b -> c) -> WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x c # (>) :: WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x b # (<*) :: WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x a #
Monoid a => Applicative (Constant a :: Type -> Type)
Instance details Defined in Data.Functor.Constant Methods pure :: a0 -> Constant a a0 # (<>) :: Constant a (a0 -> b) -> Constant a a0 -> Constant a b # liftA2 :: (a0 -> b -> c) -> Constant a a0 -> Constant a b -> Constant a c # (>) :: Constant a a0 -> Constant a b -> Constant a b # (<*) :: Constant a a0 -> Constant a b -> Constant a a0 #
(Monoid a, Monoid b) => Applicative ((,,) a b)	Since: base-4.14.0.0
Instance details Defined in GHC.Base Methods pure :: a0 -> (a, b, a0) # (<>) :: (a, b, a0 -> b0) -> (a, b, a0) -> (a, b, b0) # liftA2 :: (a0 -> b0 -> c) -> (a, b, a0) -> (a, b, b0) -> (a, b, c) # (>) :: (a, b, a0) -> (a, b, b0) -> (a, b, b0) # (<*) :: (a, b, a0) -> (a, b, b0) -> (a, b, a0) #
(Applicative f, Applicative g) => Applicative (f :*: g)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods pure :: a -> (f :: g) a # (<>) :: (f :: g) (a -> b) -> (f :: g) a -> (f :: g) b # liftA2 :: (a -> b -> c) -> (f :: g) a -> (f :: g) b -> (f :: g) c # (>) :: (f :: g) a -> (f :: g) b -> (f :: g) b # (<) :: (f :: g) a -> (f :: g) b -> (f :: g) a #
Monoid c => Applicative (K1 i c :: Type -> Type)	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods pure :: a -> K1 i c a # (<>) :: K1 i c (a -> b) -> K1 i c a -> K1 i c b # liftA2 :: (a -> b -> c0) -> K1 i c a -> K1 i c b -> K1 i c c0 # (>) :: K1 i c a -> K1 i c b -> K1 i c b # (<*) :: K1 i c a -> K1 i c b -> K1 i c a #
(Monad f, Applicative f) => Applicative (WhenMatched f x y)	Equivalent to `ReaderT Key (ReaderT x (ReaderT y (MaybeT f)))` Since: containers-0.5.9
Instance details Defined in Data.IntMap.Internal Methods pure :: a -> WhenMatched f x y a # (<>) :: WhenMatched f x y (a -> b) -> WhenMatched f x y a -> WhenMatched f x y b # liftA2 :: (a -> b -> c) -> WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y c # (>) :: WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y b # (<*) :: WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y a #
(Applicative f, Monad f) => Applicative (WhenMissing f k x)	Equivalent to `ReaderT k (ReaderT x (MaybeT f))` . Since: containers-0.5.9
Instance details Defined in Data.Map.Internal Methods pure :: a -> WhenMissing f k x a # (<>) :: WhenMissing f k x (a -> b) -> WhenMissing f k x a -> WhenMissing f k x b # liftA2 :: (a -> b -> c) -> WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x c # (>) :: WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x b # (<*) :: WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x a #
(Monoid a, Monoid b, Monoid c) => Applicative ((,,,) a b c)	Since: base-4.14.0.0
Instance details Defined in GHC.Base Methods pure :: a0 -> (a, b, c, a0) # (<>) :: (a, b, c, a0 -> b0) -> (a, b, c, a0) -> (a, b, c, b0) # liftA2 :: (a0 -> b0 -> c0) -> (a, b, c, a0) -> (a, b, c, b0) -> (a, b, c, c0) # (>) :: (a, b, c, a0) -> (a, b, c, b0) -> (a, b, c, b0) # (<*) :: (a, b, c, a0) -> (a, b, c, b0) -> (a, b, c, a0) #
Applicative ((->) r)	Since: base-2.1
Instance details Defined in GHC.Base Methods pure :: a -> r -> a # (<>) :: (r -> (a -> b)) -> (r -> a) -> r -> b # liftA2 :: (a -> b -> c) -> (r -> a) -> (r -> b) -> r -> c # (>) :: (r -> a) -> (r -> b) -> r -> b # (<*) :: (r -> a) -> (r -> b) -> r -> a #
(Applicative f, Applicative g) => Applicative (f :.: g)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods pure :: a -> (f :.: g) a # (<>) :: (f :.: g) (a -> b) -> (f :.: g) a -> (f :.: g) b # liftA2 :: (a -> b -> c) -> (f :.: g) a -> (f :.: g) b -> (f :.: g) c # (>) :: (f :.: g) a -> (f :.: g) b -> (f :.: g) b # (<*) :: (f :.: g) a -> (f :.: g) b -> (f :.: g) a #
Applicative f => Applicative (M1 i c f)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods pure :: a -> M1 i c f a # (<>) :: M1 i c f (a -> b) -> M1 i c f a -> M1 i c f b # liftA2 :: (a -> b -> c0) -> M1 i c f a -> M1 i c f b -> M1 i c f c0 # (>) :: M1 i c f a -> M1 i c f b -> M1 i c f b # (<*) :: M1 i c f a -> M1 i c f b -> M1 i c f a #
(Monad f, Applicative f) => Applicative (WhenMatched f k x y)	Equivalent to `ReaderT k (ReaderT x (ReaderT y (MaybeT f)))` Since: containers-0.5.9
Instance details Defined in Data.Map.Internal Methods pure :: a -> WhenMatched f k x y a # (<>) :: WhenMatched f k x y (a -> b) -> WhenMatched f k x y a -> WhenMatched f k x y b # liftA2 :: (a -> b -> c) -> WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y c # (>) :: WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y b # (<*) :: WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y a #

class Functor (f :: Type -> Type) where #

A type f is a Functor if it provides a function fmap which, given any types a and b lets you apply any function from (a -> b) to turn an f a into an f b, preserving the structure of f. Furthermore f needs to adhere to the following:

Identity: fmap id == id
Composition: fmap (f . g) == fmap f . fmap g

Note, that the second law follows from the free theorem of the type fmap and the first law, so you need only check that the former condition holds. See https://www.schoolofhaskell.com/user/edwardk/snippets/fmap or https://github.com/quchen/articles/blob/master/second_functor_law.md for an explanation.

Minimal complete definition

fmap

Methods

fmap :: (a -> b) -> f a -> f b #

fmap is used to apply a function of type (a -> b) to a value of type f a, where f is a functor, to produce a value of type f b. Note that for any type constructor with more than one parameter (e.g., Either), only the last type parameter can be modified with fmap (e.g., b in `Either a b`).

Some type constructors with two parameters or more have a Bifunctor instance that allows both the last and the penultimate parameters to be mapped over.

Examples

Expand

Convert from a Maybe Int to a Maybe String using show:

>>> fmap show Nothing
Nothing
>>> fmap show (Just 3)
Just "3"

Convert from an Either Int Int to an Either Int String using show:

>>> fmap show (Left 17)
Left 17
>>> fmap show (Right 17)
Right "17"

Double each element of a list:

>>> fmap (*2) [1,2,3]
[2,4,6]

Apply even to the second element of a pair:

>>> fmap even (2,2)
(2,True)

It may seem surprising that the function is only applied to the last element of the tuple compared to the list example above which applies it to every element in the list. To understand, remember that tuples are type constructors with multiple type parameters: a tuple of 3 elements (a,b,c) can also be written (,,) a b c and its Functor instance is defined for Functor ((,,) a b) (i.e., only the third parameter is free to be mapped over with fmap).

It explains why fmap can be used with tuples containing values of different types as in the following example:

>>> fmap even ("hello", 1.0, 4)
("hello",1.0,True)

(<$) :: a -> f b -> f a infixl 4 #

Replace all locations in the input with the same value. The default definition is fmap . const, but this may be overridden with a more efficient version.

Examples

Expand

Perform a computation with Maybe and replace the result with a constant value if it is Just:

>>> 'a' <$ Just 2
Just 'a'
>>> 'a' <$ Nothing
Nothing

Instances

Instances details

Functor Gen
Instance details Defined in Test.QuickCheck.Gen Methods fmap :: (a -> b) -> Gen a -> Gen b # (<$) :: a -> Gen b -> Gen a #
Functor Blind
Instance details Defined in Test.QuickCheck.Modifiers Methods fmap :: (a -> b) -> Blind a -> Blind b # (<$) :: a -> Blind b -> Blind a #
Functor Fixed
Instance details Defined in Test.QuickCheck.Modifiers Methods fmap :: (a -> b) -> Fixed a -> Fixed b # (<$) :: a -> Fixed b -> Fixed a #
Functor Large
Instance details Defined in Test.QuickCheck.Modifiers Methods fmap :: (a -> b) -> Large a -> Large b # (<$) :: a -> Large b -> Large a #
Functor Negative
Instance details Defined in Test.QuickCheck.Modifiers Methods fmap :: (a -> b) -> Negative a -> Negative b # (<$) :: a -> Negative b -> Negative a #
Functor NonEmptyList
Instance details Defined in Test.QuickCheck.Modifiers Methods fmap :: (a -> b) -> NonEmptyList a -> NonEmptyList b # (<$) :: a -> NonEmptyList b -> NonEmptyList a #
Functor NonNegative
Instance details Defined in Test.QuickCheck.Modifiers Methods fmap :: (a -> b) -> NonNegative a -> NonNegative b # (<$) :: a -> NonNegative b -> NonNegative a #
Functor NonPositive
Instance details Defined in Test.QuickCheck.Modifiers Methods fmap :: (a -> b) -> NonPositive a -> NonPositive b # (<$) :: a -> NonPositive b -> NonPositive a #
Functor NonZero
Instance details Defined in Test.QuickCheck.Modifiers Methods fmap :: (a -> b) -> NonZero a -> NonZero b # (<$) :: a -> NonZero b -> NonZero a #
Functor OrderedList
Instance details Defined in Test.QuickCheck.Modifiers Methods fmap :: (a -> b) -> OrderedList a -> OrderedList b # (<$) :: a -> OrderedList b -> OrderedList a #
Functor Positive
Instance details Defined in Test.QuickCheck.Modifiers Methods fmap :: (a -> b) -> Positive a -> Positive b # (<$) :: a -> Positive b -> Positive a #
Functor Shrink2
Instance details Defined in Test.QuickCheck.Modifiers Methods fmap :: (a -> b) -> Shrink2 a -> Shrink2 b # (<$) :: a -> Shrink2 b -> Shrink2 a #
Functor Small
Instance details Defined in Test.QuickCheck.Modifiers Methods fmap :: (a -> b) -> Small a -> Small b # (<$) :: a -> Small b -> Small a #
Functor Smart
Instance details Defined in Test.QuickCheck.Modifiers Methods fmap :: (a -> b) -> Smart a -> Smart b # (<$) :: a -> Smart b -> Smart a #
Functor SortedList
Instance details Defined in Test.QuickCheck.Modifiers Methods fmap :: (a -> b) -> SortedList a -> SortedList b # (<$) :: a -> SortedList b -> SortedList a #
Functor Rose
Instance details Defined in Test.QuickCheck.Property Methods fmap :: (a -> b) -> Rose a -> Rose b # (<$) :: a -> Rose b -> Rose a #
Functor ZipList	Since: base-2.1
Instance details Defined in Control.Applicative Methods fmap :: (a -> b) -> ZipList a -> ZipList b # (<$) :: a -> ZipList b -> ZipList a #
Functor NonEmpty	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods fmap :: (a -> b) -> NonEmpty a -> NonEmpty b # (<$) :: a -> NonEmpty b -> NonEmpty a #
Functor Par1	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> Par1 a -> Par1 b # (<$) :: a -> Par1 b -> Par1 a #
Functor P	Since: base-4.8.0.0
Instance details Defined in Text.ParserCombinators.ReadP Methods fmap :: (a -> b) -> P a -> P b # (<$) :: a -> P b -> P a #
Functor ReadP	Since: base-2.1
Instance details Defined in Text.ParserCombinators.ReadP Methods fmap :: (a -> b) -> ReadP a -> ReadP b # (<$) :: a -> ReadP b -> ReadP a #
Functor IntMap
Instance details Defined in Data.IntMap.Internal Methods fmap :: (a -> b) -> IntMap a -> IntMap b # (<$) :: a -> IntMap b -> IntMap a #
Functor Digit
Instance details Defined in Data.Sequence.Internal Methods fmap :: (a -> b) -> Digit a -> Digit b # (<$) :: a -> Digit b -> Digit a #
Functor Elem
Instance details Defined in Data.Sequence.Internal Methods fmap :: (a -> b) -> Elem a -> Elem b # (<$) :: a -> Elem b -> Elem a #
Functor FingerTree
Instance details Defined in Data.Sequence.Internal Methods fmap :: (a -> b) -> FingerTree a -> FingerTree b # (<$) :: a -> FingerTree b -> FingerTree a #
Functor Node
Instance details Defined in Data.Sequence.Internal Methods fmap :: (a -> b) -> Node a -> Node b # (<$) :: a -> Node b -> Node a #
Functor Seq
Instance details Defined in Data.Sequence.Internal Methods fmap :: (a -> b) -> Seq a -> Seq b # (<$) :: a -> Seq b -> Seq a #
Functor ViewL
Instance details Defined in Data.Sequence.Internal Methods fmap :: (a -> b) -> ViewL a -> ViewL b # (<$) :: a -> ViewL b -> ViewL a #
Functor ViewR
Instance details Defined in Data.Sequence.Internal Methods fmap :: (a -> b) -> ViewR a -> ViewR b # (<$) :: a -> ViewR b -> ViewR a #
Functor Tree
Instance details Defined in Data.Tree Methods fmap :: (a -> b) -> Tree a -> Tree b # (<$) :: a -> Tree b -> Tree a #
Functor IO	Since: base-2.1
Instance details Defined in GHC.Base Methods fmap :: (a -> b) -> IO a -> IO b # (<$) :: a -> IO b -> IO a #
Functor AnnotDetails
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods fmap :: (a -> b) -> AnnotDetails a -> AnnotDetails b # (<$) :: a -> AnnotDetails b -> AnnotDetails a #
Functor Doc
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods fmap :: (a -> b) -> Doc a -> Doc b # (<$) :: a -> Doc b -> Doc a #
Functor Span
Instance details Defined in Text.PrettyPrint.Annotated.HughesPJ Methods fmap :: (a -> b) -> Span a -> Span b # (<$) :: a -> Span b -> Span a #
Functor Array
Instance details Defined in Data.Primitive.Array Methods fmap :: (a -> b) -> Array a -> Array b # (<$) :: a -> Array b -> Array a #
Functor SmallArray
Instance details Defined in Data.Primitive.SmallArray Methods fmap :: (a -> b) -> SmallArray a -> SmallArray b # (<$) :: a -> SmallArray b -> SmallArray a #
Functor FillResult
Instance details Defined in Raaz.Core.ByteSource Methods fmap :: (a -> b) -> FillResult a -> FillResult b # (<$) :: a -> FillResult b -> FillResult a #
Functor Dest
Instance details Defined in Raaz.Core.Types.Copying Methods fmap :: (a -> b) -> Dest a -> Dest b # (<$) :: a -> Dest b -> Dest a #
Functor Src
Instance details Defined in Raaz.Core.Types.Copying Methods fmap :: (a -> b) -> Src a -> Src b # (<$) :: a -> Src b -> Src a #
Functor BE
Instance details Defined in Raaz.Core.Types.Endian Methods fmap :: (a -> b) -> BE a -> BE b # (<$) :: a -> BE b -> BE a #
Functor LE
Instance details Defined in Raaz.Core.Types.Endian Methods fmap :: (a -> b) -> LE a -> LE b # (<$) :: a -> LE b -> LE a #
Functor BYTES
Instance details Defined in Raaz.Core.Types.Pointer Methods fmap :: (a -> b) -> BYTES a -> BYTES b # (<$) :: a -> BYTES b -> BYTES a #
Functor Q
Instance details Defined in Language.Haskell.TH.Syntax Methods fmap :: (a -> b) -> Q a -> Q b # (<$) :: a -> Q b -> Q a #
Functor TyVarBndr
Instance details Defined in Language.Haskell.TH.Syntax Methods fmap :: (a -> b) -> TyVarBndr a -> TyVarBndr b # (<$) :: a -> TyVarBndr b -> TyVarBndr a #
Functor Maybe	Since: base-2.1
Instance details Defined in GHC.Base Methods fmap :: (a -> b) -> Maybe a -> Maybe b # (<$) :: a -> Maybe b -> Maybe a #
Functor Solo	Since: base-4.15
Instance details Defined in GHC.Base Methods fmap :: (a -> b) -> Solo a -> Solo b # (<$) :: a -> Solo b -> Solo a #
Functor List	Since: base-2.1
Instance details Defined in GHC.Base Methods fmap :: (a -> b) -> [a] -> [b] # (<$) :: a -> [b] -> [a] #
Functor ((:->) a)
Instance details Defined in Test.QuickCheck.Function Methods fmap :: (a0 -> b) -> (a :-> a0) -> a :-> b # (<$) :: a0 -> (a :-> b) -> a :-> a0 #
Functor (Fun a)
Instance details Defined in Test.QuickCheck.Function Methods fmap :: (a0 -> b) -> Fun a a0 -> Fun a b # (<$) :: a0 -> Fun a b -> Fun a a0 #
Functor (Shrinking s)
Instance details Defined in Test.QuickCheck.Modifiers Methods fmap :: (a -> b) -> Shrinking s a -> Shrinking s b # (<$) :: a -> Shrinking s b -> Shrinking s a #
Functor (PropertyM m)
Instance details Defined in Test.QuickCheck.Monadic Methods fmap :: (a -> b) -> PropertyM m a -> PropertyM m b # (<$) :: a -> PropertyM m b -> PropertyM m a #
Monad m => Functor (WrappedMonad m)	Since: base-2.1
Instance details Defined in Control.Applicative Methods fmap :: (a -> b) -> WrappedMonad m a -> WrappedMonad m b # (<$) :: a -> WrappedMonad m b -> WrappedMonad m a #
Functor (Either a)	Since: base-3.0
Instance details Defined in Data.Either Methods fmap :: (a0 -> b) -> Either a a0 -> Either a b # (<$) :: a0 -> Either a b -> Either a a0 #
Functor (Proxy :: Type -> Type)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods fmap :: (a -> b) -> Proxy a -> Proxy b # (<$) :: a -> Proxy b -> Proxy a #
Functor (U1 :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> U1 a -> U1 b # (<$) :: a -> U1 b -> U1 a #
Functor (V1 :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> V1 a -> V1 b # (<$) :: a -> V1 b -> V1 a #
Functor (ST s)	Since: base-2.1
Instance details Defined in GHC.ST Methods fmap :: (a -> b) -> ST s a -> ST s b # (<$) :: a -> ST s b -> ST s a #
Functor (Map k)
Instance details Defined in Data.Map.Internal Methods fmap :: (a -> b) -> Map k a -> Map k b # (<$) :: a -> Map k b -> Map k a #
Functor (SpecM a)
Instance details Defined in Test.Hspec.Core.Spec.Monad Methods fmap :: (a0 -> b) -> SpecM a a0 -> SpecM a b # (<$) :: a0 -> SpecM a b -> SpecM a a0 #
Functor ((,) a)	Since: base-2.1
Instance details Defined in GHC.Base Methods fmap :: (a0 -> b) -> (a, a0) -> (a, b) # (<$) :: a0 -> (a, b) -> (a, a0) #
Arrow a => Functor (WrappedArrow a b)	Since: base-2.1
Instance details Defined in Control.Applicative Methods fmap :: (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0 # (<$) :: a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0 #
Functor (Const m :: Type -> Type)	Since: base-2.1
Instance details Defined in Data.Functor.Const Methods fmap :: (a -> b) -> Const m a -> Const m b # (<$) :: a -> Const m b -> Const m a #
(Generic1 f, Functor (Rep1 f)) => Functor (Generically1 f)	Since: base-4.17.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> Generically1 f a -> Generically1 f b # (<$) :: a -> Generically1 f b -> Generically1 f a #
Functor f => Functor (Rec1 f)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> Rec1 f a -> Rec1 f b # (<$) :: a -> Rec1 f b -> Rec1 f a #
Functor (URec (Ptr ()) :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec (Ptr ()) a -> URec (Ptr ()) b # (<$) :: a -> URec (Ptr ()) b -> URec (Ptr ()) a #
Functor (URec Char :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec Char a -> URec Char b # (<$) :: a -> URec Char b -> URec Char a #
Functor (URec Double :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec Double a -> URec Double b # (<$) :: a -> URec Double b -> URec Double a #
Functor (URec Float :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec Float a -> URec Float b # (<$) :: a -> URec Float b -> URec Float a #
Functor (URec Int :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec Int a -> URec Int b # (<$) :: a -> URec Int b -> URec Int a #
Functor (URec Word :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec Word a -> URec Word b # (<$) :: a -> URec Word b -> URec Word a #
(Applicative f, Monad f) => Functor (WhenMissing f x)	Since: containers-0.5.9
Instance details Defined in Data.IntMap.Internal Methods fmap :: (a -> b) -> WhenMissing f x a -> WhenMissing f x b # (<$) :: a -> WhenMissing f x b -> WhenMissing f x a #
Functor (Constant a :: Type -> Type)
Instance details Defined in Data.Functor.Constant Methods fmap :: (a0 -> b) -> Constant a a0 -> Constant a b # (<$) :: a0 -> Constant a b -> Constant a a0 #
Functor ((,,) a b)	Since: base-4.14.0.0
Instance details Defined in GHC.Base Methods fmap :: (a0 -> b0) -> (a, b, a0) -> (a, b, b0) # (<$) :: a0 -> (a, b, b0) -> (a, b, a0) #
(Functor f, Functor g) => Functor (f :*: g)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> (f :: g) a -> (f :: g) b # (<$) :: a -> (f :: g) b -> (f :: g) a #
(Functor f, Functor g) => Functor (f :+: g)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> (f :+: g) a -> (f :+: g) b # (<$) :: a -> (f :+: g) b -> (f :+: g) a #
Functor (K1 i c :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> K1 i c a -> K1 i c b # (<$) :: a -> K1 i c b -> K1 i c a #
Functor f => Functor (WhenMatched f x y)	Since: containers-0.5.9
Instance details Defined in Data.IntMap.Internal Methods fmap :: (a -> b) -> WhenMatched f x y a -> WhenMatched f x y b # (<$) :: a -> WhenMatched f x y b -> WhenMatched f x y a #
(Applicative f, Monad f) => Functor (WhenMissing f k x)	Since: containers-0.5.9
Instance details Defined in Data.Map.Internal Methods fmap :: (a -> b) -> WhenMissing f k x a -> WhenMissing f k x b # (<$) :: a -> WhenMissing f k x b -> WhenMissing f k x a #
Functor ((,,,) a b c)	Since: base-4.14.0.0
Instance details Defined in GHC.Base Methods fmap :: (a0 -> b0) -> (a, b, c, a0) -> (a, b, c, b0) # (<$) :: a0 -> (a, b, c, b0) -> (a, b, c, a0) #
Functor ((->) r)	Since: base-2.1
Instance details Defined in GHC.Base Methods fmap :: (a -> b) -> (r -> a) -> r -> b # (<$) :: a -> (r -> b) -> r -> a #
(Functor f, Functor g) => Functor (f :.: g)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> (f :.: g) a -> (f :.: g) b # (<$) :: a -> (f :.: g) b -> (f :.: g) a #
Functor f => Functor (M1 i c f)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> M1 i c f a -> M1 i c f b # (<$) :: a -> M1 i c f b -> M1 i c f a #
Functor f => Functor (WhenMatched f k x y)	Since: containers-0.5.9
Instance details Defined in Data.Map.Internal Methods fmap :: (a -> b) -> WhenMatched f k x y a -> WhenMatched f k x y b # (<$) :: a -> WhenMatched f k x y b -> WhenMatched f k x y a #
Functor ((,,,,) a b c d)	Since: base-4.18.0.0
Instance details Defined in GHC.Base Methods fmap :: (a0 -> b0) -> (a, b, c, d, a0) -> (a, b, c, d, b0) # (<$) :: a0 -> (a, b, c, d, b0) -> (a, b, c, d, a0) #
Functor ((,,,,,) a b c d e)	Since: base-4.18.0.0
Instance details Defined in GHC.Base Methods fmap :: (a0 -> b0) -> (a, b, c, d, e, a0) -> (a, b, c, d, e, b0) # (<$) :: a0 -> (a, b, c, d, e, b0) -> (a, b, c, d, e, a0) #
Functor ((,,,,,,) a b c d e f)	Since: base-4.18.0.0
Instance details Defined in GHC.Base Methods fmap :: (a0 -> b0) -> (a, b, c, d, e, f, a0) -> (a, b, c, d, e, f, b0) # (<$) :: a0 -> (a, b, c, d, e, f, b0) -> (a, b, c, d, e, f, a0) #

class Applicative m => Monad (m :: Type -> Type) where #

The Monad class defines the basic operations over a monad, a concept from a branch of mathematics known as category theory. From the perspective of a Haskell programmer, however, it is best to think of a monad as an abstract datatype of actions. Haskell's do expressions provide a convenient syntax for writing monadic expressions.

Instances of Monad should satisfy the following:

Left identity: return a >>= k = k a
Right identity: m >>= return = m
Associativity: m >>= (\x -> k x >>= h) = (m >>= k) >>= h

Furthermore, the Monad and Applicative operations should relate as follows:

```
pure = return
```

m1 <*> m2 = m1 >>= (\x1 -> m2 >>= (\x2 -> return (x1 x2)))

The above laws imply:

```
fmap f xs  =  xs >>= return . f
```
```
(>>) = (*>)
```

and that pure and (<*>) satisfy the applicative functor laws.

The instances of Monad for lists, Maybe and IO defined in the Prelude satisfy these laws.

Minimal complete definition

(>>=)

Methods

(>>=) :: m a -> (a -> m b) -> m b infixl 1 #

Sequentially compose two actions, passing any value produced by the first as an argument to the second.

'as >>= bs' can be understood as the do expression

do a <- as
   bs a

(>>) :: m a -> m b -> m b infixl 1 #

Sequentially compose two actions, discarding any value produced by the first, like sequencing operators (such as the semicolon) in imperative languages.

'as >> bs' can be understood as the do expression

do as
   bs

return :: a -> m a #

Inject a value into the monadic type.

Instances

Instances details

Monad Gen
Instance details Defined in Test.QuickCheck.Gen Methods (>>=) :: Gen a -> (a -> Gen b) -> Gen b # (>>) :: Gen a -> Gen b -> Gen b # return :: a -> Gen a #
Monad Rose
Instance details Defined in Test.QuickCheck.Property Methods (>>=) :: Rose a -> (a -> Rose b) -> Rose b # (>>) :: Rose a -> Rose b -> Rose b # return :: a -> Rose a #
Monad NonEmpty	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (>>=) :: NonEmpty a -> (a -> NonEmpty b) -> NonEmpty b # (>>) :: NonEmpty a -> NonEmpty b -> NonEmpty b # return :: a -> NonEmpty a #
Monad Par1	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (>>=) :: Par1 a -> (a -> Par1 b) -> Par1 b # (>>) :: Par1 a -> Par1 b -> Par1 b # return :: a -> Par1 a #
Monad P	Since: base-2.1
Instance details Defined in Text.ParserCombinators.ReadP Methods (>>=) :: P a -> (a -> P b) -> P b # (>>) :: P a -> P b -> P b # return :: a -> P a #
Monad ReadP	Since: base-2.1
Instance details Defined in Text.ParserCombinators.ReadP Methods (>>=) :: ReadP a -> (a -> ReadP b) -> ReadP b # (>>) :: ReadP a -> ReadP b -> ReadP b # return :: a -> ReadP a #
Monad Seq
Instance details Defined in Data.Sequence.Internal Methods (>>=) :: Seq a -> (a -> Seq b) -> Seq b # (>>) :: Seq a -> Seq b -> Seq b # return :: a -> Seq a #
Monad Tree
Instance details Defined in Data.Tree Methods (>>=) :: Tree a -> (a -> Tree b) -> Tree b # (>>) :: Tree a -> Tree b -> Tree b # return :: a -> Tree a #
Monad IO	Since: base-2.1
Instance details Defined in GHC.Base Methods (>>=) :: IO a -> (a -> IO b) -> IO b # (>>) :: IO a -> IO b -> IO b # return :: a -> IO a #
Monad Array
Instance details Defined in Data.Primitive.Array Methods (>>=) :: Array a -> (a -> Array b) -> Array b # (>>) :: Array a -> Array b -> Array b # return :: a -> Array a #
Monad SmallArray
Instance details Defined in Data.Primitive.SmallArray Methods (>>=) :: SmallArray a -> (a -> SmallArray b) -> SmallArray b # (>>) :: SmallArray a -> SmallArray b -> SmallArray b # return :: a -> SmallArray a #
Monad Q
Instance details Defined in Language.Haskell.TH.Syntax Methods (>>=) :: Q a -> (a -> Q b) -> Q b # (>>) :: Q a -> Q b -> Q b # return :: a -> Q a #
Monad Maybe	Since: base-2.1
Instance details Defined in GHC.Base Methods (>>=) :: Maybe a -> (a -> Maybe b) -> Maybe b # (>>) :: Maybe a -> Maybe b -> Maybe b # return :: a -> Maybe a #
Monad Solo	Since: base-4.15
Instance details Defined in GHC.Base Methods (>>=) :: Solo a -> (a -> Solo b) -> Solo b # (>>) :: Solo a -> Solo b -> Solo b # return :: a -> Solo a #
Monad List	Since: base-2.1
Instance details Defined in GHC.Base Methods (>>=) :: [a] -> (a -> [b]) -> [b] # (>>) :: [a] -> [b] -> [b] # return :: a -> [a] #
Monad m => Monad (PropertyM m)
Instance details Defined in Test.QuickCheck.Monadic Methods (>>=) :: PropertyM m a -> (a -> PropertyM m b) -> PropertyM m b # (>>) :: PropertyM m a -> PropertyM m b -> PropertyM m b # return :: a -> PropertyM m a #
Monad m => Monad (WrappedMonad m)	Since: base-4.7.0.0
Instance details Defined in Control.Applicative Methods (>>=) :: WrappedMonad m a -> (a -> WrappedMonad m b) -> WrappedMonad m b # (>>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b # return :: a -> WrappedMonad m a #
Monad (Either e)	Since: base-4.4.0.0
Instance details Defined in Data.Either Methods (>>=) :: Either e a -> (a -> Either e b) -> Either e b # (>>) :: Either e a -> Either e b -> Either e b # return :: a -> Either e a #
Monad (Proxy :: Type -> Type)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods (>>=) :: Proxy a -> (a -> Proxy b) -> Proxy b # (>>) :: Proxy a -> Proxy b -> Proxy b # return :: a -> Proxy a #
Monad (U1 :: Type -> Type)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (>>=) :: U1 a -> (a -> U1 b) -> U1 b # (>>) :: U1 a -> U1 b -> U1 b # return :: a -> U1 a #
Monad (ST s)	Since: base-2.1
Instance details Defined in GHC.ST Methods (>>=) :: ST s a -> (a -> ST s b) -> ST s b # (>>) :: ST s a -> ST s b -> ST s b # return :: a -> ST s a #
Monad (SpecM a)
Instance details Defined in Test.Hspec.Core.Spec.Monad Methods (>>=) :: SpecM a a0 -> (a0 -> SpecM a b) -> SpecM a b # (>>) :: SpecM a a0 -> SpecM a b -> SpecM a b # return :: a0 -> SpecM a a0 #
Monoid a => Monad ((,) a)	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods (>>=) :: (a, a0) -> (a0 -> (a, b)) -> (a, b) # (>>) :: (a, a0) -> (a, b) -> (a, b) # return :: a0 -> (a, a0) #
Monad f => Monad (Rec1 f)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (>>=) :: Rec1 f a -> (a -> Rec1 f b) -> Rec1 f b # (>>) :: Rec1 f a -> Rec1 f b -> Rec1 f b # return :: a -> Rec1 f a #
(Applicative f, Monad f) => Monad (WhenMissing f x)	Equivalent to `ReaderT k (ReaderT x (MaybeT f))`. Since: containers-0.5.9
Instance details Defined in Data.IntMap.Internal Methods (>>=) :: WhenMissing f x a -> (a -> WhenMissing f x b) -> WhenMissing f x b # (>>) :: WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x b # return :: a -> WhenMissing f x a #
(Monoid a, Monoid b) => Monad ((,,) a b)	Since: base-4.14.0.0
Instance details Defined in GHC.Base Methods (>>=) :: (a, b, a0) -> (a0 -> (a, b, b0)) -> (a, b, b0) # (>>) :: (a, b, a0) -> (a, b, b0) -> (a, b, b0) # return :: a0 -> (a, b, a0) #
(Monad f, Monad g) => Monad (f :*: g)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (>>=) :: (f :: g) a -> (a -> (f :: g) b) -> (f :: g) b # (>>) :: (f :: g) a -> (f :: g) b -> (f :: g) b # return :: a -> (f :*: g) a #
(Monad f, Applicative f) => Monad (WhenMatched f x y)	Equivalent to `ReaderT Key (ReaderT x (ReaderT y (MaybeT f)))` Since: containers-0.5.9
Instance details Defined in Data.IntMap.Internal Methods (>>=) :: WhenMatched f x y a -> (a -> WhenMatched f x y b) -> WhenMatched f x y b # (>>) :: WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y b # return :: a -> WhenMatched f x y a #
(Applicative f, Monad f) => Monad (WhenMissing f k x)	Equivalent to `ReaderT k (ReaderT x (MaybeT f))` . Since: containers-0.5.9
Instance details Defined in Data.Map.Internal Methods (>>=) :: WhenMissing f k x a -> (a -> WhenMissing f k x b) -> WhenMissing f k x b # (>>) :: WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x b # return :: a -> WhenMissing f k x a #
(Monoid a, Monoid b, Monoid c) => Monad ((,,,) a b c)	Since: base-4.14.0.0
Instance details Defined in GHC.Base Methods (>>=) :: (a, b, c, a0) -> (a0 -> (a, b, c, b0)) -> (a, b, c, b0) # (>>) :: (a, b, c, a0) -> (a, b, c, b0) -> (a, b, c, b0) # return :: a0 -> (a, b, c, a0) #
Monad ((->) r)	Since: base-2.1
Instance details Defined in GHC.Base Methods (>>=) :: (r -> a) -> (a -> r -> b) -> r -> b # (>>) :: (r -> a) -> (r -> b) -> r -> b # return :: a -> r -> a #
Monad f => Monad (M1 i c f)	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (>>=) :: M1 i c f a -> (a -> M1 i c f b) -> M1 i c f b # (>>) :: M1 i c f a -> M1 i c f b -> M1 i c f b # return :: a -> M1 i c f a #
(Monad f, Applicative f) => Monad (WhenMatched f k x y)	Equivalent to `ReaderT k (ReaderT x (ReaderT y (MaybeT f)))` Since: containers-0.5.9
Instance details Defined in Data.Map.Internal Methods (>>=) :: WhenMatched f k x y a -> (a -> WhenMatched f k x y b) -> WhenMatched f k x y b # (>>) :: WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y b # return :: a -> WhenMatched f k x y a #

data Fun a b #

Generation of random shrinkable, showable functions.

To generate random values of type Fun a b, you must have an instance Function a.

See also applyFun, and Fn with GHC >= 7.8.

Constructors

Fun (a :-> b, b, Shrunk) (a -> b)

Instances

Instances details

Functor (Fun a)
Instance details Defined in Test.QuickCheck.Function Methods fmap :: (a0 -> b) -> Fun a a0 -> Fun a b # (<$) :: a0 -> Fun a b -> Fun a a0 #
(Function a, CoArbitrary a, Arbitrary b) => Arbitrary (Fun a b)
Instance details Defined in Test.QuickCheck.Function Methods arbitrary :: Gen (Fun a b) # shrink :: Fun a b -> [Fun a b] #
(Show a, Show b) => Show (Fun a b)
Instance details Defined in Test.QuickCheck.Function Methods showsPrec :: Int -> Fun a b -> ShowS # show :: Fun a b -> String # showList :: [Fun a b] -> ShowS #

data Gen a #

A generator for values of type a.

The third-party packages QuickCheck-GenT and quickcheck-transformer provide monad transformer versions of Gen.

Instances

Instances details

MonadFix Gen
Instance details Defined in Test.QuickCheck.Gen Methods mfix :: (a -> Gen a) -> Gen a #
Applicative Gen
Instance details Defined in Test.QuickCheck.Gen Methods pure :: a -> Gen a # (<>) :: Gen (a -> b) -> Gen a -> Gen b # liftA2 :: (a -> b -> c) -> Gen a -> Gen b -> Gen c # (>) :: Gen a -> Gen b -> Gen b # (<*) :: Gen a -> Gen b -> Gen a #
Functor Gen
Instance details Defined in Test.QuickCheck.Gen Methods fmap :: (a -> b) -> Gen a -> Gen b # (<$) :: a -> Gen b -> Gen a #
Monad Gen
Instance details Defined in Test.QuickCheck.Gen Methods (>>=) :: Gen a -> (a -> Gen b) -> Gen b # (>>) :: Gen a -> Gen b -> Gen b # return :: a -> Gen a #
Testable prop => Testable (Gen prop)
Instance details Defined in Test.QuickCheck.Property Methods property :: Gen prop -> Property # propertyForAllShrinkShow :: Gen a -> (a -> [a]) -> (a -> [String]) -> (a -> Gen prop) -> Property #

class CoArbitrary a where #

Used for random generation of functions. You should consider using Fun instead, which can show the generated functions as strings.

If you are using a recent GHC, there is a default definition of coarbitrary using genericCoarbitrary, so if your type has a Generic instance it's enough to say

instance CoArbitrary MyType

You should only use genericCoarbitrary for data types where equality is structural, i.e. if you can't have two different representations of the same value. An example where it's not safe is sets implemented using binary search trees: the same set can be represented as several different trees. Here you would have to explicitly define coarbitrary s = coarbitrary (toList s).

Minimal complete definition

Nothing

Methods

coarbitrary :: a -> Gen b -> Gen b #

Used to generate a function of type a -> b. The first argument is a value, the second a generator. You should use variant to perturb the random generator; the goal is that different values for the first argument will lead to different calls to variant. An example will help:

instance CoArbitrary a => CoArbitrary [a] where
  coarbitrary []     = variant 0
  coarbitrary (x:xs) = variant 1 . coarbitrary (x,xs)

Instances

Instances details

CoArbitrary All
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: All -> Gen b -> Gen b #
CoArbitrary Any
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Any -> Gen b -> Gen b #
CoArbitrary Version
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Version -> Gen b -> Gen b #
CoArbitrary Newline
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Newline -> Gen b -> Gen b #
CoArbitrary NewlineMode
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: NewlineMode -> Gen b -> Gen b #
CoArbitrary Int16
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Int16 -> Gen b -> Gen b #
CoArbitrary Int32
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Int32 -> Gen b -> Gen b #
CoArbitrary Int64
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Int64 -> Gen b -> Gen b #
CoArbitrary Int8
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Int8 -> Gen b -> Gen b #
CoArbitrary Word16
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Word16 -> Gen b -> Gen b #
CoArbitrary Word32
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Word32 -> Gen b -> Gen b #
CoArbitrary Word64
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Word64 -> Gen b -> Gen b #
CoArbitrary Word8
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Word8 -> Gen b -> Gen b #
CoArbitrary IntSet
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: IntSet -> Gen b -> Gen b #
CoArbitrary Ordering
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Ordering -> Gen b -> Gen b #
CoArbitrary Integer
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Integer -> Gen b -> Gen b #
CoArbitrary ()
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: () -> Gen b -> Gen b #
CoArbitrary Bool
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Bool -> Gen b -> Gen b #
CoArbitrary Char
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Char -> Gen b -> Gen b #
CoArbitrary Double
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Double -> Gen b -> Gen b #
CoArbitrary Float
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Float -> Gen b -> Gen b #
CoArbitrary Int
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Int -> Gen b -> Gen b #
CoArbitrary Word
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Word -> Gen b -> Gen b #
CoArbitrary a => CoArbitrary (ZipList a)
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: ZipList a -> Gen b -> Gen b #
CoArbitrary a => CoArbitrary (Complex a)
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Complex a -> Gen b -> Gen b #
CoArbitrary a => CoArbitrary (Identity a)
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Identity a -> Gen b -> Gen b #
CoArbitrary a => CoArbitrary (First a)
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: First a -> Gen b -> Gen b #
CoArbitrary a => CoArbitrary (Last a)
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Last a -> Gen b -> Gen b #
CoArbitrary a => CoArbitrary (Dual a)
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Dual a -> Gen b -> Gen b #
(Arbitrary a, CoArbitrary a) => CoArbitrary (Endo a)
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Endo a -> Gen b -> Gen b #
CoArbitrary a => CoArbitrary (Product a)
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Product a -> Gen b -> Gen b #
CoArbitrary a => CoArbitrary (Sum a)
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Sum a -> Gen b -> Gen b #
(Integral a, CoArbitrary a) => CoArbitrary (Ratio a)
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Ratio a -> Gen b -> Gen b #
CoArbitrary a => CoArbitrary (IntMap a)
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: IntMap a -> Gen b -> Gen b #
CoArbitrary a => CoArbitrary (Seq a)
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Seq a -> Gen b -> Gen b #
CoArbitrary a => CoArbitrary (Set a)
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Set a -> Gen b -> Gen b #
CoArbitrary a => CoArbitrary (Tree a)
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Tree a -> Gen b -> Gen b #
CoArbitrary a => CoArbitrary (Maybe a)
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Maybe a -> Gen b -> Gen b #
CoArbitrary a => CoArbitrary [a]
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: [a] -> Gen b -> Gen b #
(CoArbitrary a, CoArbitrary b) => CoArbitrary (Either a b)
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Either a b -> Gen b0 -> Gen b0 #
HasResolution a => CoArbitrary (Fixed a)
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Fixed a -> Gen b -> Gen b #
(CoArbitrary k, CoArbitrary v) => CoArbitrary (Map k v)
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Map k v -> Gen b -> Gen b #
(CoArbitrary a, CoArbitrary b) => CoArbitrary (a, b)
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: (a, b) -> Gen b0 -> Gen b0 #
(Arbitrary a, CoArbitrary b) => CoArbitrary (a -> b)
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: (a -> b) -> Gen b0 -> Gen b0 #
CoArbitrary a => CoArbitrary (Const a b)
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Const a b -> Gen b0 -> Gen b0 #
CoArbitrary (f a) => CoArbitrary (Alt f a)
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Alt f a -> Gen b -> Gen b #
CoArbitrary a => CoArbitrary (Constant a b)
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: Constant a b -> Gen b0 -> Gen b0 #
(CoArbitrary a, CoArbitrary b, CoArbitrary c) => CoArbitrary (a, b, c)
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: (a, b, c) -> Gen b0 -> Gen b0 #
(CoArbitrary a, CoArbitrary b, CoArbitrary c, CoArbitrary d) => CoArbitrary (a, b, c, d)
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: (a, b, c, d) -> Gen b0 -> Gen b0 #
(CoArbitrary a, CoArbitrary b, CoArbitrary c, CoArbitrary d, CoArbitrary e) => CoArbitrary (a, b, c, d, e)
Instance details Defined in Test.QuickCheck.Arbitrary Methods coarbitrary :: (a, b, c, d, e) -> Gen b0 -> Gen b0 #

class Arbitrary2 (f :: Type -> Type -> Type) where #

Lifting of the Arbitrary class to binary type constructors.

Minimal complete definition

liftArbitrary2

Methods

liftArbitrary2 :: Gen a -> Gen b -> Gen (f a b) #

liftShrink2 :: (a -> [a]) -> (b -> [b]) -> f a b -> [f a b] #

Instances

Instances details

Arbitrary2 Either
Instance details Defined in Test.QuickCheck.Arbitrary Methods liftArbitrary2 :: Gen a -> Gen b -> Gen (Either a b) # liftShrink2 :: (a -> [a]) -> (b -> [b]) -> Either a b -> [Either a b] #
Arbitrary2 (,)
Instance details Defined in Test.QuickCheck.Arbitrary Methods liftArbitrary2 :: Gen a -> Gen b -> Gen (a, b) # liftShrink2 :: (a -> [a]) -> (b -> [b]) -> (a, b) -> [(a, b)] #
Arbitrary2 (Const :: Type -> Type -> Type)
Instance details Defined in Test.QuickCheck.Arbitrary Methods liftArbitrary2 :: Gen a -> Gen b -> Gen (Const a b) # liftShrink2 :: (a -> [a]) -> (b -> [b]) -> Const a b -> [Const a b] #
Arbitrary2 (Constant :: Type -> Type -> Type)
Instance details Defined in Test.QuickCheck.Arbitrary Methods liftArbitrary2 :: Gen a -> Gen b -> Gen (Constant a b) # liftShrink2 :: (a -> [a]) -> (b -> [b]) -> Constant a b -> [Constant a b] #

class Arbitrary1 (f :: Type -> Type) where #

Lifting of the Arbitrary class to unary type constructors.

Minimal complete definition

liftArbitrary

Methods

liftArbitrary :: Gen a -> Gen (f a) #

liftShrink :: (a -> [a]) -> f a -> [f a] #

Instances

Instances details

Arbitrary1 ZipList
Instance details Defined in Test.QuickCheck.Arbitrary Methods liftArbitrary :: Gen a -> Gen (ZipList a) # liftShrink :: (a -> [a]) -> ZipList a -> [ZipList a] #
Arbitrary1 Identity
Instance details Defined in Test.QuickCheck.Arbitrary Methods liftArbitrary :: Gen a -> Gen (Identity a) # liftShrink :: (a -> [a]) -> Identity a -> [Identity a] #
Arbitrary1 IntMap	WARNING: The same warning as for `Arbitrary (Set a)` applies here.
Instance details Defined in Test.QuickCheck.Arbitrary Methods liftArbitrary :: Gen a -> Gen (IntMap a) # liftShrink :: (a -> [a]) -> IntMap a -> [IntMap a] #
Arbitrary1 Seq
Instance details Defined in Test.QuickCheck.Arbitrary Methods liftArbitrary :: Gen a -> Gen (Seq a) # liftShrink :: (a -> [a]) -> Seq a -> [Seq a] #
Arbitrary1 Tree
Instance details Defined in Test.QuickCheck.Arbitrary Methods liftArbitrary :: Gen a -> Gen (Tree a) # liftShrink :: (a -> [a]) -> Tree a -> [Tree a] #
Arbitrary1 Maybe
Instance details Defined in Test.QuickCheck.Arbitrary Methods liftArbitrary :: Gen a -> Gen (Maybe a) # liftShrink :: (a -> [a]) -> Maybe a -> [Maybe a] #
Arbitrary1 List
Instance details Defined in Test.QuickCheck.Arbitrary Methods liftArbitrary :: Gen a -> Gen [a] # liftShrink :: (a -> [a]) -> [a] -> [[a]] #
Arbitrary a => Arbitrary1 (Either a)
Instance details Defined in Test.QuickCheck.Arbitrary Methods liftArbitrary :: Gen a0 -> Gen (Either a a0) # liftShrink :: (a0 -> [a0]) -> Either a a0 -> [Either a a0] #
(Ord k, Arbitrary k) => Arbitrary1 (Map k)
Instance details Defined in Test.QuickCheck.Arbitrary Methods liftArbitrary :: Gen a -> Gen (Map k a) # liftShrink :: (a -> [a]) -> Map k a -> [Map k a] #
Arbitrary a => Arbitrary1 ((,) a)
Instance details Defined in Test.QuickCheck.Arbitrary Methods liftArbitrary :: Gen a0 -> Gen (a, a0) # liftShrink :: (a0 -> [a0]) -> (a, a0) -> [(a, a0)] #
Arbitrary a => Arbitrary1 (Const a :: Type -> Type)
Instance details Defined in Test.QuickCheck.Arbitrary Methods liftArbitrary :: Gen a0 -> Gen (Const a a0) # liftShrink :: (a0 -> [a0]) -> Const a a0 -> [Const a a0] #
Arbitrary a => Arbitrary1 (Constant a :: Type -> Type)
Instance details Defined in Test.QuickCheck.Arbitrary Methods liftArbitrary :: Gen a0 -> Gen (Constant a a0) # liftShrink :: (a0 -> [a0]) -> Constant a a0 -> [Constant a a0] #
(Arbitrary1 f, Arbitrary1 g) => Arbitrary1 (Product f g)
Instance details Defined in Test.QuickCheck.Arbitrary Methods liftArbitrary :: Gen a -> Gen (Product f g a) # liftShrink :: (a -> [a]) -> Product f g a -> [Product f g a] #
CoArbitrary a => Arbitrary1 ((->) a)
Instance details Defined in Test.QuickCheck.Arbitrary Methods liftArbitrary :: Gen a0 -> Gen (a -> a0) # liftShrink :: (a0 -> [a0]) -> (a -> a0) -> [a -> a0] #
(Arbitrary1 f, Arbitrary1 g) => Arbitrary1 (Compose f g)
Instance details Defined in Test.QuickCheck.Arbitrary Methods liftArbitrary :: Gen a -> Gen (Compose f g a) # liftShrink :: (a -> [a]) -> Compose f g a -> [Compose f g a] #

class Arbitrary a where #

Random generation and shrinking of values.

QuickCheck provides Arbitrary instances for most types in base, except those which incur extra dependencies. For a wider range of Arbitrary instances see the quickcheck-instances package.

Minimal complete definition

arbitrary

Methods

arbitrary :: Gen a #

A generator for values of the given type.

It is worth spending time thinking about what sort of test data you want - good generators are often the difference between finding bugs and not finding them. You can use sample, label and classify to check the quality of your test data.

There is no generic arbitrary implementation included because we don't know how to make a high-quality one. If you want one, consider using the testing-feat or generic-random packages.

The QuickCheck manual goes into detail on how to write good generators. Make sure to look at it, especially if your type is recursive!

shrink :: a -> [a] #

Produces a (possibly) empty list of all the possible immediate shrinks of the given value.

The default implementation returns the empty list, so will not try to shrink the value. If your data type has no special invariants, you can enable shrinking by defining shrink = genericShrink, but by customising the behaviour of shrink you can often get simpler counterexamples.

Most implementations of shrink should try at least three things:

Shrink a term to any of its immediate subterms. You can use subterms to do this.
Recursively apply shrink to all immediate subterms. You can use recursivelyShrink to do this.
Type-specific shrinkings such as replacing a constructor by a simpler constructor.

For example, suppose we have the following implementation of binary trees:

data Tree a = Nil | Branch a (Tree a) (Tree a)

We can then define shrink as follows:

shrink Nil = []
shrink (Branch x l r) =
  -- shrink Branch to Nil
  [Nil] ++
  -- shrink to subterms
  [l, r] ++
  -- recursively shrink subterms
  [Branch x' l' r' | (x', l', r') <- shrink (x, l, r)]

There are a couple of subtleties here:

QuickCheck tries the shrinking candidates in the order they appear in the list, so we put more aggressive shrinking steps (such as replacing the whole tree by Nil) before smaller ones (such as recursively shrinking the subtrees).
It is tempting to write the last line as [Branch x' l' r' | x' <- shrink x, l' <- shrink l, r' <- shrink r] but this is the wrong thing! It will force QuickCheck to shrink x, l and r in tandem, and shrinking will stop once one of the three is fully shrunk.

There is a fair bit of boilerplate in the code above. We can avoid it with the help of some generic functions. The function genericShrink tries shrinking a term to all of its subterms and, failing that, recursively shrinks the subterms. Using it, we can define shrink as:

shrink x = shrinkToNil x ++ genericShrink x
  where
    shrinkToNil Nil = []
    shrinkToNil (Branch _ l r) = [Nil]

genericShrink is a combination of subterms, which shrinks a term to any of its subterms, and recursivelyShrink, which shrinks all subterms of a term. These may be useful if you need a bit more control over shrinking than genericShrink gives you.

A final gotcha: we cannot define shrink as simply shrink x = Nil:genericShrink x as this shrinks Nil to Nil, and shrinking will go into an infinite loop.

If all this leaves you bewildered, you might try shrink = genericShrink to begin with, after deriving Generic for your type. However, if your data type has any special invariants, you will need to check that genericShrink can't break those invariants.

Instances

Instances details

Arbitrary ASCIIString
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen ASCIIString # shrink :: ASCIIString -> [ASCIIString] #
Arbitrary PrintableString
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen PrintableString # shrink :: PrintableString -> [PrintableString] #
Arbitrary UnicodeString
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen UnicodeString # shrink :: UnicodeString -> [UnicodeString] #
Arbitrary QCGen
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen QCGen # shrink :: QCGen -> [QCGen] #
Arbitrary All
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen All # shrink :: All -> [All] #
Arbitrary Any
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen Any # shrink :: Any -> [Any] #
Arbitrary Version	Generates `Version` with non-empty non-negative `versionBranch`, and empty `versionTags`
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen Version # shrink :: Version -> [Version] #
Arbitrary CChar
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen CChar # shrink :: CChar -> [CChar] #
Arbitrary CClock
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen CClock # shrink :: CClock -> [CClock] #
Arbitrary CDouble
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen CDouble # shrink :: CDouble -> [CDouble] #
Arbitrary CFloat
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen CFloat # shrink :: CFloat -> [CFloat] #
Arbitrary CInt
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen CInt # shrink :: CInt -> [CInt] #
Arbitrary CIntMax
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen CIntMax # shrink :: CIntMax -> [CIntMax] #
Arbitrary CIntPtr
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen CIntPtr # shrink :: CIntPtr -> [CIntPtr] #
Arbitrary CLLong
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen CLLong # shrink :: CLLong -> [CLLong] #
Arbitrary CLong
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen CLong # shrink :: CLong -> [CLong] #
Arbitrary CPtrdiff
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen CPtrdiff # shrink :: CPtrdiff -> [CPtrdiff] #
Arbitrary CSChar
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen CSChar # shrink :: CSChar -> [CSChar] #
Arbitrary CSUSeconds
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen CSUSeconds # shrink :: CSUSeconds -> [CSUSeconds] #
Arbitrary CShort
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen CShort # shrink :: CShort -> [CShort] #
Arbitrary CSigAtomic
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen CSigAtomic # shrink :: CSigAtomic -> [CSigAtomic] #
Arbitrary CSize
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen CSize # shrink :: CSize -> [CSize] #
Arbitrary CTime
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen CTime # shrink :: CTime -> [CTime] #
Arbitrary CUChar
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen CUChar # shrink :: CUChar -> [CUChar] #
Arbitrary CUInt
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen CUInt # shrink :: CUInt -> [CUInt] #
Arbitrary CUIntMax
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen CUIntMax # shrink :: CUIntMax -> [CUIntMax] #
Arbitrary CUIntPtr
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen CUIntPtr # shrink :: CUIntPtr -> [CUIntPtr] #
Arbitrary CULLong
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen CULLong # shrink :: CULLong -> [CULLong] #
Arbitrary CULong
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen CULong # shrink :: CULong -> [CULong] #
Arbitrary CUSeconds
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen CUSeconds # shrink :: CUSeconds -> [CUSeconds] #
Arbitrary CUShort
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen CUShort # shrink :: CUShort -> [CUShort] #
Arbitrary CWchar
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen CWchar # shrink :: CWchar -> [CWchar] #
Arbitrary ExitCode
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen ExitCode # shrink :: ExitCode -> [ExitCode] #
Arbitrary Newline
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen Newline # shrink :: Newline -> [Newline] #
Arbitrary NewlineMode
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen NewlineMode # shrink :: NewlineMode -> [NewlineMode] #
Arbitrary Int16
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen Int16 # shrink :: Int16 -> [Int16] #
Arbitrary Int32
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen Int32 # shrink :: Int32 -> [Int32] #
Arbitrary Int64
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen Int64 # shrink :: Int64 -> [Int64] #
Arbitrary Int8
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen Int8 # shrink :: Int8 -> [Int8] #
Arbitrary Word16
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen Word16 # shrink :: Word16 -> [Word16] #
Arbitrary Word32
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen Word32 # shrink :: Word32 -> [Word32] #
Arbitrary Word64
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen Word64 # shrink :: Word64 -> [Word64] #
Arbitrary Word8
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen Word8 # shrink :: Word8 -> [Word8] #
Arbitrary ByteString Source #
Instance details Defined in Tests.Core.Instances Methods arbitrary :: Gen ByteString # shrink :: ByteString -> [ByteString] #
Arbitrary IntSet	WARNING: The same warning as for `Arbitrary (Set a)` applies here.
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen IntSet # shrink :: IntSet -> [IntSet] #
Arbitrary Ordering
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen Ordering # shrink :: Ordering -> [Ordering] #
Arbitrary Base16 Source #
Instance details Defined in Tests.Core.Instances Methods arbitrary :: Gen Base16 # shrink :: Base16 -> [Base16] #
Arbitrary Base64 Source #
Instance details Defined in Tests.Core.Instances Methods arbitrary :: Gen Base64 # shrink :: Base64 -> [Base64] #
Arbitrary Blake2b Source #
Instance details Defined in Tests.Core.Instances Methods arbitrary :: Gen Blake2b # shrink :: Blake2b -> [Blake2b] #
Arbitrary Blake2s Source #
Instance details Defined in Tests.Core.Instances Methods arbitrary :: Gen Blake2s # shrink :: Blake2s -> [Blake2s] #
Arbitrary Poly1305 Source #
Instance details Defined in Tests.Core.Instances Methods arbitrary :: Gen Poly1305 # shrink :: Poly1305 -> [Poly1305] #
Arbitrary R Source #
Instance details Defined in Tests.Core.Instances Methods arbitrary :: Gen R # shrink :: R -> [R] #
Arbitrary S Source #
Instance details Defined in Tests.Core.Instances Methods arbitrary :: Gen S # shrink :: S -> [S] #
Arbitrary Sha256 Source #
Instance details Defined in Tests.Core.Instances Methods arbitrary :: Gen Sha256 # shrink :: Sha256 -> [Sha256] #
Arbitrary Sha512 Source #
Instance details Defined in Tests.Core.Instances Methods arbitrary :: Gen Sha512 # shrink :: Sha512 -> [Sha512] #
Arbitrary Integer
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen Integer # shrink :: Integer -> [Integer] #
Arbitrary ()
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen () # shrink :: () -> [()] #
Arbitrary Bool
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen Bool # shrink :: Bool -> [Bool] #
Arbitrary Char
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen Char # shrink :: Char -> [Char] #
Arbitrary Double
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen Double # shrink :: Double -> [Double] #
Arbitrary Float
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen Float # shrink :: Float -> [Float] #
Arbitrary Int
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen Int # shrink :: Int -> [Int] #
Arbitrary Word
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen Word # shrink :: Word -> [Word] #
Arbitrary a => Arbitrary (Blind a)
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (Blind a) # shrink :: Blind a -> [Blind a] #
Arbitrary a => Arbitrary (Fixed a)
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (Fixed a) # shrink :: Fixed a -> [Fixed a] #
Arbitrary a => Arbitrary (InfiniteList a)
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (InfiniteList a) # shrink :: InfiniteList a -> [InfiniteList a] #
Arbitrary a => Arbitrary (InfiniteListInternalData a)
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (InfiniteListInternalData a) # shrink :: InfiniteListInternalData a -> [InfiniteListInternalData a] #
(Integral a, Bounded a) => Arbitrary (Large a)
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (Large a) # shrink :: Large a -> [Large a] #
(Num a, Ord a, Arbitrary a) => Arbitrary (Negative a)
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (Negative a) # shrink :: Negative a -> [Negative a] #
Arbitrary a => Arbitrary (NonEmptyList a)
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (NonEmptyList a) # shrink :: NonEmptyList a -> [NonEmptyList a] #
(Num a, Ord a, Arbitrary a) => Arbitrary (NonNegative a)
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (NonNegative a) # shrink :: NonNegative a -> [NonNegative a] #
(Num a, Ord a, Arbitrary a) => Arbitrary (NonPositive a)
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (NonPositive a) # shrink :: NonPositive a -> [NonPositive a] #
(Num a, Eq a, Arbitrary a) => Arbitrary (NonZero a)
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (NonZero a) # shrink :: NonZero a -> [NonZero a] #
(Ord a, Arbitrary a) => Arbitrary (OrderedList a)
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (OrderedList a) # shrink :: OrderedList a -> [OrderedList a] #
(Num a, Ord a, Arbitrary a) => Arbitrary (Positive a)
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (Positive a) # shrink :: Positive a -> [Positive a] #
Arbitrary a => Arbitrary (Shrink2 a)
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (Shrink2 a) # shrink :: Shrink2 a -> [Shrink2 a] #
Integral a => Arbitrary (Small a)
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (Small a) # shrink :: Small a -> [Small a] #
Arbitrary a => Arbitrary (Smart a)
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (Smart a) # shrink :: Smart a -> [Smart a] #
(Arbitrary a, Ord a) => Arbitrary (SortedList a)
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (SortedList a) # shrink :: SortedList a -> [SortedList a] #
Arbitrary a => Arbitrary (ZipList a)
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (ZipList a) # shrink :: ZipList a -> [ZipList a] #
Arbitrary a => Arbitrary (Complex a)
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (Complex a) # shrink :: Complex a -> [Complex a] #
Arbitrary a => Arbitrary (Identity a)
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (Identity a) # shrink :: Identity a -> [Identity a] #
Arbitrary a => Arbitrary (First a)
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (First a) # shrink :: First a -> [First a] #
Arbitrary a => Arbitrary (Last a)
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (Last a) # shrink :: Last a -> [Last a] #
Arbitrary a => Arbitrary (Dual a)
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (Dual a) # shrink :: Dual a -> [Dual a] #
(Arbitrary a, CoArbitrary a) => Arbitrary (Endo a)
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (Endo a) # shrink :: Endo a -> [Endo a] #
Arbitrary a => Arbitrary (Product a)
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (Product a) # shrink :: Product a -> [Product a] #
Arbitrary a => Arbitrary (Sum a)
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (Sum a) # shrink :: Sum a -> [Sum a] #
Integral a => Arbitrary (Ratio a)
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (Ratio a) # shrink :: Ratio a -> [Ratio a] #
Arbitrary a => Arbitrary (IntMap a)	WARNING: The same warning as for `Arbitrary (Set a)` applies here.
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (IntMap a) # shrink :: IntMap a -> [IntMap a] #
Arbitrary a => Arbitrary (Seq a)	WARNING: The same warning as for `Arbitrary (Set a)` applies here.
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (Seq a) # shrink :: Seq a -> [Seq a] #
(Ord a, Arbitrary a) => Arbitrary (Set a)	WARNING: Users working on the internals of the `Set` type via e.g. `Data.Set.Internal` should be aware that this instance aims to give a good representation of `Set a` as mathematical sets but does not aim to provide a varied distribution over the underlying representation.
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (Set a) # shrink :: Set a -> [Set a] #
Arbitrary a => Arbitrary (Tree a)
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (Tree a) # shrink :: Tree a -> [Tree a] #
Arbitrary (BlockCount ChaCha20) Source #
Instance details Defined in Tests.Core.Instances Methods arbitrary :: Gen (BlockCount ChaCha20) # shrink :: BlockCount ChaCha20 -> [BlockCount ChaCha20] #
Arbitrary (BlockCount XChaCha20) Source #
Instance details Defined in Tests.Core.Instances Methods arbitrary :: Gen (BlockCount XChaCha20) # shrink :: BlockCount XChaCha20 -> [BlockCount XChaCha20] #
Arbitrary (Key ChaCha20) Source #
Instance details Defined in Tests.Core.Instances Methods arbitrary :: Gen (Key ChaCha20) # shrink :: Key ChaCha20 -> [Key ChaCha20] #
Arbitrary (Key XChaCha20) Source #
Instance details Defined in Tests.Core.Instances Methods arbitrary :: Gen (Key XChaCha20) # shrink :: Key XChaCha20 -> [Key XChaCha20] #
Arbitrary (Key (Keyed prim)) Source #
Instance details Defined in Tests.Core.Instances Methods arbitrary :: Gen (Key (Keyed prim)) # shrink :: Key (Keyed prim) -> [Key (Keyed prim)] #
Arbitrary (Key Poly1305) Source #
Instance details Defined in Tests.Core.Instances Methods arbitrary :: Gen (Key Poly1305) # shrink :: Key Poly1305 -> [Key Poly1305] #
Arbitrary (Nounce ChaCha20) Source #
Instance details Defined in Tests.Core.Instances Methods arbitrary :: Gen (Nounce ChaCha20) # shrink :: Nounce ChaCha20 -> [Nounce ChaCha20] #
Arbitrary (Nounce XChaCha20) Source #
Instance details Defined in Tests.Core.Instances Methods arbitrary :: Gen (Nounce XChaCha20) # shrink :: Nounce XChaCha20 -> [Nounce XChaCha20] #
Arbitrary w => Arbitrary (BE w) Source #
Instance details Defined in Tests.Core.Instances Methods arbitrary :: Gen (BE w) # shrink :: BE w -> [BE w] #
Arbitrary w => Arbitrary (LE w) Source #
Instance details Defined in Tests.Core.Instances Methods arbitrary :: Gen (LE w) # shrink :: LE w -> [LE w] #
Arbitrary w => Arbitrary (BYTES w) Source #
Instance details Defined in Tests.Core.Instances Methods arbitrary :: Gen (BYTES w) # shrink :: BYTES w -> [BYTES w] #
Arbitrary a => Arbitrary (Maybe a)
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (Maybe a) # shrink :: Maybe a -> [Maybe a] #
Arbitrary a => Arbitrary [a]
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen [a] # shrink :: [a] -> [[a]] #
(Function a, CoArbitrary a, Arbitrary b) => Arbitrary (a :-> b)
Instance details Defined in Test.QuickCheck.Function Methods arbitrary :: Gen (a :-> b) # shrink :: (a :-> b) -> [a :-> b] #
(Function a, CoArbitrary a, Arbitrary b) => Arbitrary (Fun a b)
Instance details Defined in Test.QuickCheck.Function Methods arbitrary :: Gen (Fun a b) # shrink :: Fun a b -> [Fun a b] #
(Arbitrary a, ShrinkState s a) => Arbitrary (Shrinking s a)
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (Shrinking s a) # shrink :: Shrinking s a -> [Shrinking s a] #
Arbitrary (m a) => Arbitrary (WrappedMonad m a)
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (WrappedMonad m a) # shrink :: WrappedMonad m a -> [WrappedMonad m a] #
(Arbitrary a, Arbitrary b) => Arbitrary (Either a b)
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (Either a b) # shrink :: Either a b -> [Either a b] #
HasResolution a => Arbitrary (Fixed a)
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (Fixed a) # shrink :: Fixed a -> [Fixed a] #
(Ord k, Arbitrary k, Arbitrary v) => Arbitrary (Map k v)	WARNING: The same warning as for `Arbitrary (Set a)` applies here.
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (Map k v) # shrink :: Map k v -> [Map k v] #
(Arbitrary a, Arbitrary b) => Arbitrary (a, b)
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (a, b) # shrink :: (a, b) -> [(a, b)] #
(CoArbitrary a, Arbitrary b) => Arbitrary (a -> b)
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (a -> b) # shrink :: (a -> b) -> [a -> b] #
Arbitrary (a b c) => Arbitrary (WrappedArrow a b c)
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (WrappedArrow a b c) # shrink :: WrappedArrow a b c -> [WrappedArrow a b c] #
Arbitrary a => Arbitrary (Const a b)
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (Const a b) # shrink :: Const a b -> [Const a b] #
Arbitrary (f a) => Arbitrary (Alt f a)
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (Alt f a) # shrink :: Alt f a -> [Alt f a] #
Arbitrary a => Arbitrary (Constant a b)
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (Constant a b) # shrink :: Constant a b -> [Constant a b] #
(Arbitrary a, Arbitrary b, Arbitrary c) => Arbitrary (a, b, c)
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (a, b, c) # shrink :: (a, b, c) -> [(a, b, c)] #
(Arbitrary1 f, Arbitrary1 g, Arbitrary a) => Arbitrary (Product f g a)
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (Product f g a) # shrink :: Product f g a -> [Product f g a] #
(Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d) => Arbitrary (a, b, c, d)
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (a, b, c, d) # shrink :: (a, b, c, d) -> [(a, b, c, d)] #
(Arbitrary1 f, Arbitrary1 g, Arbitrary a) => Arbitrary (Compose f g a)
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (Compose f g a) # shrink :: Compose f g a -> [Compose f g a] #
(Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d, Arbitrary e) => Arbitrary (a, b, c, d, e)
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (a, b, c, d, e) # shrink :: (a, b, c, d, e) -> [(a, b, c, d, e)] #
(Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d, Arbitrary e, Arbitrary f) => Arbitrary (a, b, c, d, e, f)
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (a, b, c, d, e, f) # shrink :: (a, b, c, d, e, f) -> [(a, b, c, d, e, f)] #
(Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d, Arbitrary e, Arbitrary f, Arbitrary g) => Arbitrary (a, b, c, d, e, f, g)
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (a, b, c, d, e, f, g) # shrink :: (a, b, c, d, e, f, g) -> [(a, b, c, d, e, f, g)] #
(Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d, Arbitrary e, Arbitrary f, Arbitrary g, Arbitrary h) => Arbitrary (a, b, c, d, e, f, g, h)
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (a, b, c, d, e, f, g, h) # shrink :: (a, b, c, d, e, f, g, h) -> [(a, b, c, d, e, f, g, h)] #
(Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d, Arbitrary e, Arbitrary f, Arbitrary g, Arbitrary h, Arbitrary i) => Arbitrary (a, b, c, d, e, f, g, h, i)
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (a, b, c, d, e, f, g, h, i) # shrink :: (a, b, c, d, e, f, g, h, i) -> [(a, b, c, d, e, f, g, h, i)] #
(Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d, Arbitrary e, Arbitrary f, Arbitrary g, Arbitrary h, Arbitrary i, Arbitrary j) => Arbitrary (a, b, c, d, e, f, g, h, i, j)
Instance details Defined in Test.QuickCheck.Arbitrary Methods arbitrary :: Gen (a, b, c, d, e, f, g, h, i, j) # shrink :: (a, b, c, d, e, f, g, h, i, j) -> [(a, b, c, d, e, f, g, h, i, j)] #

newtype PrintableString #

PrintableString: generates a printable unicode String. The string will not contain surrogate pairs.

Constructors

PrintableString
Fields getPrintableString :: String

Instances

Instances details

Arbitrary PrintableString
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen PrintableString # shrink :: PrintableString -> [PrintableString] #
Read PrintableString
Instance details Defined in Test.QuickCheck.Modifiers Methods readsPrec :: Int -> ReadS PrintableString # readList :: ReadS [PrintableString] # readPrec :: ReadPrec PrintableString # readListPrec :: ReadPrec [PrintableString] #
Show PrintableString
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> PrintableString -> ShowS # show :: PrintableString -> String # showList :: [PrintableString] -> ShowS #
Eq PrintableString
Instance details Defined in Test.QuickCheck.Modifiers Methods (==) :: PrintableString -> PrintableString -> Bool # (/=) :: PrintableString -> PrintableString -> Bool #
Ord PrintableString
Instance details Defined in Test.QuickCheck.Modifiers Methods compare :: PrintableString -> PrintableString -> Ordering # (<) :: PrintableString -> PrintableString -> Bool # (<=) :: PrintableString -> PrintableString -> Bool # (>) :: PrintableString -> PrintableString -> Bool # (>=) :: PrintableString -> PrintableString -> Bool # max :: PrintableString -> PrintableString -> PrintableString # min :: PrintableString -> PrintableString -> PrintableString #

newtype UnicodeString #

UnicodeString: generates a unicode String. The string will not contain surrogate pairs.

Constructors

UnicodeString
Fields getUnicodeString :: String

Instances

Instances details

Arbitrary UnicodeString
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen UnicodeString # shrink :: UnicodeString -> [UnicodeString] #
Read UnicodeString
Instance details Defined in Test.QuickCheck.Modifiers Methods readsPrec :: Int -> ReadS UnicodeString # readList :: ReadS [UnicodeString] # readPrec :: ReadPrec UnicodeString # readListPrec :: ReadPrec [UnicodeString] #
Show UnicodeString
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> UnicodeString -> ShowS # show :: UnicodeString -> String # showList :: [UnicodeString] -> ShowS #
Eq UnicodeString
Instance details Defined in Test.QuickCheck.Modifiers Methods (==) :: UnicodeString -> UnicodeString -> Bool # (/=) :: UnicodeString -> UnicodeString -> Bool #
Ord UnicodeString
Instance details Defined in Test.QuickCheck.Modifiers Methods compare :: UnicodeString -> UnicodeString -> Ordering # (<) :: UnicodeString -> UnicodeString -> Bool # (<=) :: UnicodeString -> UnicodeString -> Bool # (>) :: UnicodeString -> UnicodeString -> Bool # (>=) :: UnicodeString -> UnicodeString -> Bool # max :: UnicodeString -> UnicodeString -> UnicodeString # min :: UnicodeString -> UnicodeString -> UnicodeString #

newtype ASCIIString #

ASCIIString: generates an ASCII string.

Constructors

ASCIIString
Fields getASCIIString :: String

Instances

Instances details

Arbitrary ASCIIString
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen ASCIIString # shrink :: ASCIIString -> [ASCIIString] #
Read ASCIIString
Instance details Defined in Test.QuickCheck.Modifiers Methods readsPrec :: Int -> ReadS ASCIIString # readList :: ReadS [ASCIIString] # readPrec :: ReadPrec ASCIIString # readListPrec :: ReadPrec [ASCIIString] #
Show ASCIIString
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> ASCIIString -> ShowS # show :: ASCIIString -> String # showList :: [ASCIIString] -> ShowS #
Eq ASCIIString
Instance details Defined in Test.QuickCheck.Modifiers Methods (==) :: ASCIIString -> ASCIIString -> Bool # (/=) :: ASCIIString -> ASCIIString -> Bool #
Ord ASCIIString
Instance details Defined in Test.QuickCheck.Modifiers Methods compare :: ASCIIString -> ASCIIString -> Ordering # (<) :: ASCIIString -> ASCIIString -> Bool # (<=) :: ASCIIString -> ASCIIString -> Bool # (>) :: ASCIIString -> ASCIIString -> Bool # (>=) :: ASCIIString -> ASCIIString -> Bool # max :: ASCIIString -> ASCIIString -> ASCIIString # min :: ASCIIString -> ASCIIString -> ASCIIString #

class ShrinkState s a where #

Methods

shrinkInit :: a -> s #

shrinkState :: a -> s -> [(a, s)] #

data Shrinking s a #

Shrinking _ x: allows for maintaining a state during shrinking.

Constructors

Shrinking s a

Instances

Instances details

Functor (Shrinking s)
Instance details Defined in Test.QuickCheck.Modifiers Methods fmap :: (a -> b) -> Shrinking s a -> Shrinking s b # (<$) :: a -> Shrinking s b -> Shrinking s a #
(Arbitrary a, ShrinkState s a) => Arbitrary (Shrinking s a)
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (Shrinking s a) # shrink :: Shrinking s a -> [Shrinking s a] #
Show a => Show (Shrinking s a)
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> Shrinking s a -> ShowS # show :: Shrinking s a -> String # showList :: [Shrinking s a] -> ShowS #

data Smart a #

Smart _ x: tries a different order when shrinking.

Constructors

Smart Int a

Instances

Instances details

Functor Smart
Instance details Defined in Test.QuickCheck.Modifiers Methods fmap :: (a -> b) -> Smart a -> Smart b # (<$) :: a -> Smart b -> Smart a #
Arbitrary a => Arbitrary (Smart a)
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (Smart a) # shrink :: Smart a -> [Smart a] #
Show a => Show (Smart a)
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> Smart a -> ShowS # show :: Smart a -> String # showList :: [Smart a] -> ShowS #

newtype Shrink2 a #

Shrink2 x: allows 2 shrinking steps at the same time when shrinking x

Constructors

Shrink2
Fields getShrink2 :: a

Instances

Instances details

Functor Shrink2
Instance details Defined in Test.QuickCheck.Modifiers Methods fmap :: (a -> b) -> Shrink2 a -> Shrink2 b # (<$) :: a -> Shrink2 b -> Shrink2 a #
Arbitrary a => Arbitrary (Shrink2 a)
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (Shrink2 a) # shrink :: Shrink2 a -> [Shrink2 a] #
Enum a => Enum (Shrink2 a)
Instance details Defined in Test.QuickCheck.Modifiers Methods succ :: Shrink2 a -> Shrink2 a # pred :: Shrink2 a -> Shrink2 a # toEnum :: Int -> Shrink2 a # fromEnum :: Shrink2 a -> Int # enumFrom :: Shrink2 a -> [Shrink2 a] # enumFromThen :: Shrink2 a -> Shrink2 a -> [Shrink2 a] # enumFromTo :: Shrink2 a -> Shrink2 a -> [Shrink2 a] # enumFromThenTo :: Shrink2 a -> Shrink2 a -> Shrink2 a -> [Shrink2 a] #
Num a => Num (Shrink2 a)
Instance details Defined in Test.QuickCheck.Modifiers Methods (+) :: Shrink2 a -> Shrink2 a -> Shrink2 a # (-) :: Shrink2 a -> Shrink2 a -> Shrink2 a # (*) :: Shrink2 a -> Shrink2 a -> Shrink2 a # negate :: Shrink2 a -> Shrink2 a # abs :: Shrink2 a -> Shrink2 a # signum :: Shrink2 a -> Shrink2 a # fromInteger :: Integer -> Shrink2 a #
Read a => Read (Shrink2 a)
Instance details Defined in Test.QuickCheck.Modifiers Methods readsPrec :: Int -> ReadS (Shrink2 a) # readList :: ReadS [Shrink2 a] # readPrec :: ReadPrec (Shrink2 a) # readListPrec :: ReadPrec [Shrink2 a] #
Integral a => Integral (Shrink2 a)
Instance details Defined in Test.QuickCheck.Modifiers Methods quot :: Shrink2 a -> Shrink2 a -> Shrink2 a # rem :: Shrink2 a -> Shrink2 a -> Shrink2 a # div :: Shrink2 a -> Shrink2 a -> Shrink2 a # mod :: Shrink2 a -> Shrink2 a -> Shrink2 a # quotRem :: Shrink2 a -> Shrink2 a -> (Shrink2 a, Shrink2 a) # divMod :: Shrink2 a -> Shrink2 a -> (Shrink2 a, Shrink2 a) # toInteger :: Shrink2 a -> Integer #
Real a => Real (Shrink2 a)
Instance details Defined in Test.QuickCheck.Modifiers Methods toRational :: Shrink2 a -> Rational #
Show a => Show (Shrink2 a)
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> Shrink2 a -> ShowS # show :: Shrink2 a -> String # showList :: [Shrink2 a] -> ShowS #
Eq a => Eq (Shrink2 a)
Instance details Defined in Test.QuickCheck.Modifiers Methods (==) :: Shrink2 a -> Shrink2 a -> Bool # (/=) :: Shrink2 a -> Shrink2 a -> Bool #
Ord a => Ord (Shrink2 a)
Instance details Defined in Test.QuickCheck.Modifiers Methods compare :: Shrink2 a -> Shrink2 a -> Ordering # (<) :: Shrink2 a -> Shrink2 a -> Bool # (<=) :: Shrink2 a -> Shrink2 a -> Bool # (>) :: Shrink2 a -> Shrink2 a -> Bool # (>=) :: Shrink2 a -> Shrink2 a -> Bool # max :: Shrink2 a -> Shrink2 a -> Shrink2 a # min :: Shrink2 a -> Shrink2 a -> Shrink2 a #

newtype Small a #

Small x: generates values of x drawn from a small range. The opposite of Large.

Constructors

Small
Fields getSmall :: a

Instances

Instances details

Functor Small
Instance details Defined in Test.QuickCheck.Modifiers Methods fmap :: (a -> b) -> Small a -> Small b # (<$) :: a -> Small b -> Small a #
Integral a => Arbitrary (Small a)
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (Small a) # shrink :: Small a -> [Small a] #
Enum a => Enum (Small a)
Instance details Defined in Test.QuickCheck.Modifiers Methods succ :: Small a -> Small a # pred :: Small a -> Small a # toEnum :: Int -> Small a # fromEnum :: Small a -> Int # enumFrom :: Small a -> [Small a] # enumFromThen :: Small a -> Small a -> [Small a] # enumFromTo :: Small a -> Small a -> [Small a] # enumFromThenTo :: Small a -> Small a -> Small a -> [Small a] #
Ix a => Ix (Small a)
Instance details Defined in Test.QuickCheck.Modifiers Methods range :: (Small a, Small a) -> [Small a] # index :: (Small a, Small a) -> Small a -> Int # unsafeIndex :: (Small a, Small a) -> Small a -> Int # inRange :: (Small a, Small a) -> Small a -> Bool # rangeSize :: (Small a, Small a) -> Int # unsafeRangeSize :: (Small a, Small a) -> Int #
Num a => Num (Small a)
Instance details Defined in Test.QuickCheck.Modifiers Methods (+) :: Small a -> Small a -> Small a # (-) :: Small a -> Small a -> Small a # (*) :: Small a -> Small a -> Small a # negate :: Small a -> Small a # abs :: Small a -> Small a # signum :: Small a -> Small a # fromInteger :: Integer -> Small a #
Read a => Read (Small a)
Instance details Defined in Test.QuickCheck.Modifiers Methods readsPrec :: Int -> ReadS (Small a) # readList :: ReadS [Small a] # readPrec :: ReadPrec (Small a) # readListPrec :: ReadPrec [Small a] #
Integral a => Integral (Small a)
Instance details Defined in Test.QuickCheck.Modifiers Methods quot :: Small a -> Small a -> Small a # rem :: Small a -> Small a -> Small a # div :: Small a -> Small a -> Small a # mod :: Small a -> Small a -> Small a # quotRem :: Small a -> Small a -> (Small a, Small a) # divMod :: Small a -> Small a -> (Small a, Small a) # toInteger :: Small a -> Integer #
Real a => Real (Small a)
Instance details Defined in Test.QuickCheck.Modifiers Methods toRational :: Small a -> Rational #
Show a => Show (Small a)
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> Small a -> ShowS # show :: Small a -> String # showList :: [Small a] -> ShowS #
Eq a => Eq (Small a)
Instance details Defined in Test.QuickCheck.Modifiers Methods (==) :: Small a -> Small a -> Bool # (/=) :: Small a -> Small a -> Bool #
Ord a => Ord (Small a)
Instance details Defined in Test.QuickCheck.Modifiers Methods compare :: Small a -> Small a -> Ordering # (<) :: Small a -> Small a -> Bool # (<=) :: Small a -> Small a -> Bool # (>) :: Small a -> Small a -> Bool # (>=) :: Small a -> Small a -> Bool # max :: Small a -> Small a -> Small a # min :: Small a -> Small a -> Small a #

newtype Large a #

Large x: by default, QuickCheck generates Ints drawn from a small range. Large Int gives you values drawn from the entire range instead.

Constructors

Large
Fields getLarge :: a

Instances

Instances details

Functor Large
Instance details Defined in Test.QuickCheck.Modifiers Methods fmap :: (a -> b) -> Large a -> Large b # (<$) :: a -> Large b -> Large a #
(Integral a, Bounded a) => Arbitrary (Large a)
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (Large a) # shrink :: Large a -> [Large a] #
Enum a => Enum (Large a)
Instance details Defined in Test.QuickCheck.Modifiers Methods succ :: Large a -> Large a # pred :: Large a -> Large a # toEnum :: Int -> Large a # fromEnum :: Large a -> Int # enumFrom :: Large a -> [Large a] # enumFromThen :: Large a -> Large a -> [Large a] # enumFromTo :: Large a -> Large a -> [Large a] # enumFromThenTo :: Large a -> Large a -> Large a -> [Large a] #
Ix a => Ix (Large a)
Instance details Defined in Test.QuickCheck.Modifiers Methods range :: (Large a, Large a) -> [Large a] # index :: (Large a, Large a) -> Large a -> Int # unsafeIndex :: (Large a, Large a) -> Large a -> Int # inRange :: (Large a, Large a) -> Large a -> Bool # rangeSize :: (Large a, Large a) -> Int # unsafeRangeSize :: (Large a, Large a) -> Int #
Num a => Num (Large a)
Instance details Defined in Test.QuickCheck.Modifiers Methods (+) :: Large a -> Large a -> Large a # (-) :: Large a -> Large a -> Large a # (*) :: Large a -> Large a -> Large a # negate :: Large a -> Large a # abs :: Large a -> Large a # signum :: Large a -> Large a # fromInteger :: Integer -> Large a #
Read a => Read (Large a)
Instance details Defined in Test.QuickCheck.Modifiers Methods readsPrec :: Int -> ReadS (Large a) # readList :: ReadS [Large a] # readPrec :: ReadPrec (Large a) # readListPrec :: ReadPrec [Large a] #
Integral a => Integral (Large a)
Instance details Defined in Test.QuickCheck.Modifiers Methods quot :: Large a -> Large a -> Large a # rem :: Large a -> Large a -> Large a # div :: Large a -> Large a -> Large a # mod :: Large a -> Large a -> Large a # quotRem :: Large a -> Large a -> (Large a, Large a) # divMod :: Large a -> Large a -> (Large a, Large a) # toInteger :: Large a -> Integer #
Real a => Real (Large a)
Instance details Defined in Test.QuickCheck.Modifiers Methods toRational :: Large a -> Rational #
Show a => Show (Large a)
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> Large a -> ShowS # show :: Large a -> String # showList :: [Large a] -> ShowS #
Eq a => Eq (Large a)
Instance details Defined in Test.QuickCheck.Modifiers Methods (==) :: Large a -> Large a -> Bool # (/=) :: Large a -> Large a -> Bool #
Ord a => Ord (Large a)
Instance details Defined in Test.QuickCheck.Modifiers Methods compare :: Large a -> Large a -> Ordering # (<) :: Large a -> Large a -> Bool # (<=) :: Large a -> Large a -> Bool # (>) :: Large a -> Large a -> Bool # (>=) :: Large a -> Large a -> Bool # max :: Large a -> Large a -> Large a # min :: Large a -> Large a -> Large a #

newtype NonPositive a #

NonPositive x: guarantees that x <= 0.

Constructors

NonPositive
Fields getNonPositive :: a

Instances

Instances details

Functor NonPositive
Instance details Defined in Test.QuickCheck.Modifiers Methods fmap :: (a -> b) -> NonPositive a -> NonPositive b # (<$) :: a -> NonPositive b -> NonPositive a #
(Num a, Ord a, Arbitrary a) => Arbitrary (NonPositive a)
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (NonPositive a) # shrink :: NonPositive a -> [NonPositive a] #
Enum a => Enum (NonPositive a)
Instance details Defined in Test.QuickCheck.Modifiers Methods succ :: NonPositive a -> NonPositive a # pred :: NonPositive a -> NonPositive a # toEnum :: Int -> NonPositive a # fromEnum :: NonPositive a -> Int # enumFrom :: NonPositive a -> [NonPositive a] # enumFromThen :: NonPositive a -> NonPositive a -> [NonPositive a] # enumFromTo :: NonPositive a -> NonPositive a -> [NonPositive a] # enumFromThenTo :: NonPositive a -> NonPositive a -> NonPositive a -> [NonPositive a] #
Read a => Read (NonPositive a)
Instance details Defined in Test.QuickCheck.Modifiers Methods readsPrec :: Int -> ReadS (NonPositive a) # readList :: ReadS [NonPositive a] # readPrec :: ReadPrec (NonPositive a) # readListPrec :: ReadPrec [NonPositive a] #
Show a => Show (NonPositive a)
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> NonPositive a -> ShowS # show :: NonPositive a -> String # showList :: [NonPositive a] -> ShowS #
Eq a => Eq (NonPositive a)
Instance details Defined in Test.QuickCheck.Modifiers Methods (==) :: NonPositive a -> NonPositive a -> Bool # (/=) :: NonPositive a -> NonPositive a -> Bool #
Ord a => Ord (NonPositive a)
Instance details Defined in Test.QuickCheck.Modifiers Methods compare :: NonPositive a -> NonPositive a -> Ordering # (<) :: NonPositive a -> NonPositive a -> Bool # (<=) :: NonPositive a -> NonPositive a -> Bool # (>) :: NonPositive a -> NonPositive a -> Bool # (>=) :: NonPositive a -> NonPositive a -> Bool # max :: NonPositive a -> NonPositive a -> NonPositive a # min :: NonPositive a -> NonPositive a -> NonPositive a #

newtype NonNegative a #

NonNegative x: guarantees that x >= 0.

Constructors

NonNegative
Fields getNonNegative :: a

Instances

Instances details

Functor NonNegative
Instance details Defined in Test.QuickCheck.Modifiers Methods fmap :: (a -> b) -> NonNegative a -> NonNegative b # (<$) :: a -> NonNegative b -> NonNegative a #
(Num a, Ord a, Arbitrary a) => Arbitrary (NonNegative a)
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (NonNegative a) # shrink :: NonNegative a -> [NonNegative a] #
Enum a => Enum (NonNegative a)
Instance details Defined in Test.QuickCheck.Modifiers Methods succ :: NonNegative a -> NonNegative a # pred :: NonNegative a -> NonNegative a # toEnum :: Int -> NonNegative a # fromEnum :: NonNegative a -> Int # enumFrom :: NonNegative a -> [NonNegative a] # enumFromThen :: NonNegative a -> NonNegative a -> [NonNegative a] # enumFromTo :: NonNegative a -> NonNegative a -> [NonNegative a] # enumFromThenTo :: NonNegative a -> NonNegative a -> NonNegative a -> [NonNegative a] #
Read a => Read (NonNegative a)
Instance details Defined in Test.QuickCheck.Modifiers Methods readsPrec :: Int -> ReadS (NonNegative a) # readList :: ReadS [NonNegative a] # readPrec :: ReadPrec (NonNegative a) # readListPrec :: ReadPrec [NonNegative a] #
Show a => Show (NonNegative a)
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> NonNegative a -> ShowS # show :: NonNegative a -> String # showList :: [NonNegative a] -> ShowS #
Eq a => Eq (NonNegative a)
Instance details Defined in Test.QuickCheck.Modifiers Methods (==) :: NonNegative a -> NonNegative a -> Bool # (/=) :: NonNegative a -> NonNegative a -> Bool #
Ord a => Ord (NonNegative a)
Instance details Defined in Test.QuickCheck.Modifiers Methods compare :: NonNegative a -> NonNegative a -> Ordering # (<) :: NonNegative a -> NonNegative a -> Bool # (<=) :: NonNegative a -> NonNegative a -> Bool # (>) :: NonNegative a -> NonNegative a -> Bool # (>=) :: NonNegative a -> NonNegative a -> Bool # max :: NonNegative a -> NonNegative a -> NonNegative a # min :: NonNegative a -> NonNegative a -> NonNegative a #

newtype NonZero a #

NonZero x: guarantees that x /= 0.

Constructors

NonZero
Fields getNonZero :: a

Instances

Instances details

Functor NonZero
Instance details Defined in Test.QuickCheck.Modifiers Methods fmap :: (a -> b) -> NonZero a -> NonZero b # (<$) :: a -> NonZero b -> NonZero a #
(Num a, Eq a, Arbitrary a) => Arbitrary (NonZero a)
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (NonZero a) # shrink :: NonZero a -> [NonZero a] #
Enum a => Enum (NonZero a)
Instance details Defined in Test.QuickCheck.Modifiers Methods succ :: NonZero a -> NonZero a # pred :: NonZero a -> NonZero a # toEnum :: Int -> NonZero a # fromEnum :: NonZero a -> Int # enumFrom :: NonZero a -> [NonZero a] # enumFromThen :: NonZero a -> NonZero a -> [NonZero a] # enumFromTo :: NonZero a -> NonZero a -> [NonZero a] # enumFromThenTo :: NonZero a -> NonZero a -> NonZero a -> [NonZero a] #
Read a => Read (NonZero a)
Instance details Defined in Test.QuickCheck.Modifiers Methods readsPrec :: Int -> ReadS (NonZero a) # readList :: ReadS [NonZero a] # readPrec :: ReadPrec (NonZero a) # readListPrec :: ReadPrec [NonZero a] #
Show a => Show (NonZero a)
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> NonZero a -> ShowS # show :: NonZero a -> String # showList :: [NonZero a] -> ShowS #
Eq a => Eq (NonZero a)
Instance details Defined in Test.QuickCheck.Modifiers Methods (==) :: NonZero a -> NonZero a -> Bool # (/=) :: NonZero a -> NonZero a -> Bool #
Ord a => Ord (NonZero a)
Instance details Defined in Test.QuickCheck.Modifiers Methods compare :: NonZero a -> NonZero a -> Ordering # (<) :: NonZero a -> NonZero a -> Bool # (<=) :: NonZero a -> NonZero a -> Bool # (>) :: NonZero a -> NonZero a -> Bool # (>=) :: NonZero a -> NonZero a -> Bool # max :: NonZero a -> NonZero a -> NonZero a # min :: NonZero a -> NonZero a -> NonZero a #

newtype Negative a #

Negative x: guarantees that x < 0.

Constructors

Negative
Fields getNegative :: a

Instances

Instances details

Functor Negative
Instance details Defined in Test.QuickCheck.Modifiers Methods fmap :: (a -> b) -> Negative a -> Negative b # (<$) :: a -> Negative b -> Negative a #
(Num a, Ord a, Arbitrary a) => Arbitrary (Negative a)
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (Negative a) # shrink :: Negative a -> [Negative a] #
Enum a => Enum (Negative a)
Instance details Defined in Test.QuickCheck.Modifiers Methods succ :: Negative a -> Negative a # pred :: Negative a -> Negative a # toEnum :: Int -> Negative a # fromEnum :: Negative a -> Int # enumFrom :: Negative a -> [Negative a] # enumFromThen :: Negative a -> Negative a -> [Negative a] # enumFromTo :: Negative a -> Negative a -> [Negative a] # enumFromThenTo :: Negative a -> Negative a -> Negative a -> [Negative a] #
Read a => Read (Negative a)
Instance details Defined in Test.QuickCheck.Modifiers Methods readsPrec :: Int -> ReadS (Negative a) # readList :: ReadS [Negative a] # readPrec :: ReadPrec (Negative a) # readListPrec :: ReadPrec [Negative a] #
Show a => Show (Negative a)
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> Negative a -> ShowS # show :: Negative a -> String # showList :: [Negative a] -> ShowS #
Eq a => Eq (Negative a)
Instance details Defined in Test.QuickCheck.Modifiers Methods (==) :: Negative a -> Negative a -> Bool # (/=) :: Negative a -> Negative a -> Bool #
Ord a => Ord (Negative a)
Instance details Defined in Test.QuickCheck.Modifiers Methods compare :: Negative a -> Negative a -> Ordering # (<) :: Negative a -> Negative a -> Bool # (<=) :: Negative a -> Negative a -> Bool # (>) :: Negative a -> Negative a -> Bool # (>=) :: Negative a -> Negative a -> Bool # max :: Negative a -> Negative a -> Negative a # min :: Negative a -> Negative a -> Negative a #

newtype Positive a #

Positive x: guarantees that x > 0.

Constructors

Positive
Fields getPositive :: a

Instances

Instances details

Functor Positive
Instance details Defined in Test.QuickCheck.Modifiers Methods fmap :: (a -> b) -> Positive a -> Positive b # (<$) :: a -> Positive b -> Positive a #
(Num a, Ord a, Arbitrary a) => Arbitrary (Positive a)
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (Positive a) # shrink :: Positive a -> [Positive a] #
Enum a => Enum (Positive a)
Instance details Defined in Test.QuickCheck.Modifiers Methods succ :: Positive a -> Positive a # pred :: Positive a -> Positive a # toEnum :: Int -> Positive a # fromEnum :: Positive a -> Int # enumFrom :: Positive a -> [Positive a] # enumFromThen :: Positive a -> Positive a -> [Positive a] # enumFromTo :: Positive a -> Positive a -> [Positive a] # enumFromThenTo :: Positive a -> Positive a -> Positive a -> [Positive a] #
Read a => Read (Positive a)
Instance details Defined in Test.QuickCheck.Modifiers Methods readsPrec :: Int -> ReadS (Positive a) # readList :: ReadS [Positive a] # readPrec :: ReadPrec (Positive a) # readListPrec :: ReadPrec [Positive a] #
Show a => Show (Positive a)
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> Positive a -> ShowS # show :: Positive a -> String # showList :: [Positive a] -> ShowS #
Eq a => Eq (Positive a)
Instance details Defined in Test.QuickCheck.Modifiers Methods (==) :: Positive a -> Positive a -> Bool # (/=) :: Positive a -> Positive a -> Bool #
Ord a => Ord (Positive a)
Instance details Defined in Test.QuickCheck.Modifiers Methods compare :: Positive a -> Positive a -> Ordering # (<) :: Positive a -> Positive a -> Bool # (<=) :: Positive a -> Positive a -> Bool # (>) :: Positive a -> Positive a -> Bool # (>=) :: Positive a -> Positive a -> Bool # max :: Positive a -> Positive a -> Positive a # min :: Positive a -> Positive a -> Positive a #

newtype SortedList a #

Sorted xs: guarantees that xs is sorted.

Constructors

Sorted
Fields getSorted :: [a]

Instances

Instances details

Functor SortedList
Instance details Defined in Test.QuickCheck.Modifiers Methods fmap :: (a -> b) -> SortedList a -> SortedList b # (<$) :: a -> SortedList b -> SortedList a #
(Arbitrary a, Ord a) => Arbitrary (SortedList a)
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (SortedList a) # shrink :: SortedList a -> [SortedList a] #
Read a => Read (SortedList a)
Instance details Defined in Test.QuickCheck.Modifiers Methods readsPrec :: Int -> ReadS (SortedList a) # readList :: ReadS [SortedList a] # readPrec :: ReadPrec (SortedList a) # readListPrec :: ReadPrec [SortedList a] #
Show a => Show (SortedList a)
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> SortedList a -> ShowS # show :: SortedList a -> String # showList :: [SortedList a] -> ShowS #
Eq a => Eq (SortedList a)
Instance details Defined in Test.QuickCheck.Modifiers Methods (==) :: SortedList a -> SortedList a -> Bool # (/=) :: SortedList a -> SortedList a -> Bool #
Ord a => Ord (SortedList a)
Instance details Defined in Test.QuickCheck.Modifiers Methods compare :: SortedList a -> SortedList a -> Ordering # (<) :: SortedList a -> SortedList a -> Bool # (<=) :: SortedList a -> SortedList a -> Bool # (>) :: SortedList a -> SortedList a -> Bool # (>=) :: SortedList a -> SortedList a -> Bool # max :: SortedList a -> SortedList a -> SortedList a # min :: SortedList a -> SortedList a -> SortedList a #

data InfiniteList a #

InfiniteList xs _: guarantees that xs is an infinite list. When a counterexample is found, only prints the prefix of xs that was used by the program.

Here is a contrived example property:

prop_take_10 :: InfiniteList Char -> Bool
prop_take_10 (InfiniteList xs _) =
  or [ x == 'a' | x <- take 10 xs ]

In the following counterexample, the list must start with "bbbbbbbbbb" but the remaining (infinite) part can contain anything:

>>> quickCheck prop_take_10
*** Failed! Falsified (after 1 test and 14 shrinks):
"bbbbbbbbbb" ++ ...

Constructors

InfiniteList
Fields getInfiniteList :: [a] infiniteListInternalData :: InfiniteListInternalData a

Instances

Instances details

Arbitrary a => Arbitrary (InfiniteList a)
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (InfiniteList a) # shrink :: InfiniteList a -> [InfiniteList a] #
Show a => Show (InfiniteList a)
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> InfiniteList a -> ShowS # show :: InfiniteList a -> String # showList :: [InfiniteList a] -> ShowS #

newtype NonEmptyList a #

NonEmpty xs: guarantees that xs is non-empty.

Constructors

NonEmpty
Fields getNonEmpty :: [a]

Instances

Instances details

Functor NonEmptyList
Instance details Defined in Test.QuickCheck.Modifiers Methods fmap :: (a -> b) -> NonEmptyList a -> NonEmptyList b # (<$) :: a -> NonEmptyList b -> NonEmptyList a #
Arbitrary a => Arbitrary (NonEmptyList a)
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (NonEmptyList a) # shrink :: NonEmptyList a -> [NonEmptyList a] #
Read a => Read (NonEmptyList a)
Instance details Defined in Test.QuickCheck.Modifiers Methods readsPrec :: Int -> ReadS (NonEmptyList a) # readList :: ReadS [NonEmptyList a] # readPrec :: ReadPrec (NonEmptyList a) # readListPrec :: ReadPrec [NonEmptyList a] #
Show a => Show (NonEmptyList a)
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> NonEmptyList a -> ShowS # show :: NonEmptyList a -> String # showList :: [NonEmptyList a] -> ShowS #
Eq a => Eq (NonEmptyList a)
Instance details Defined in Test.QuickCheck.Modifiers Methods (==) :: NonEmptyList a -> NonEmptyList a -> Bool # (/=) :: NonEmptyList a -> NonEmptyList a -> Bool #
Ord a => Ord (NonEmptyList a)
Instance details Defined in Test.QuickCheck.Modifiers Methods compare :: NonEmptyList a -> NonEmptyList a -> Ordering # (<) :: NonEmptyList a -> NonEmptyList a -> Bool # (<=) :: NonEmptyList a -> NonEmptyList a -> Bool # (>) :: NonEmptyList a -> NonEmptyList a -> Bool # (>=) :: NonEmptyList a -> NonEmptyList a -> Bool # max :: NonEmptyList a -> NonEmptyList a -> NonEmptyList a # min :: NonEmptyList a -> NonEmptyList a -> NonEmptyList a #

newtype OrderedList a #

Ordered xs: guarantees that xs is ordered.

Constructors

Ordered
Fields getOrdered :: [a]

Instances

Instances details

Functor OrderedList
Instance details Defined in Test.QuickCheck.Modifiers Methods fmap :: (a -> b) -> OrderedList a -> OrderedList b # (<$) :: a -> OrderedList b -> OrderedList a #
(Ord a, Arbitrary a) => Arbitrary (OrderedList a)
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (OrderedList a) # shrink :: OrderedList a -> [OrderedList a] #
Read a => Read (OrderedList a)
Instance details Defined in Test.QuickCheck.Modifiers Methods readsPrec :: Int -> ReadS (OrderedList a) # readList :: ReadS [OrderedList a] # readPrec :: ReadPrec (OrderedList a) # readListPrec :: ReadPrec [OrderedList a] #
Show a => Show (OrderedList a)
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> OrderedList a -> ShowS # show :: OrderedList a -> String # showList :: [OrderedList a] -> ShowS #
Eq a => Eq (OrderedList a)
Instance details Defined in Test.QuickCheck.Modifiers Methods (==) :: OrderedList a -> OrderedList a -> Bool # (/=) :: OrderedList a -> OrderedList a -> Bool #
Ord a => Ord (OrderedList a)
Instance details Defined in Test.QuickCheck.Modifiers Methods compare :: OrderedList a -> OrderedList a -> Ordering # (<) :: OrderedList a -> OrderedList a -> Bool # (<=) :: OrderedList a -> OrderedList a -> Bool # (>) :: OrderedList a -> OrderedList a -> Bool # (>=) :: OrderedList a -> OrderedList a -> Bool # max :: OrderedList a -> OrderedList a -> OrderedList a # min :: OrderedList a -> OrderedList a -> OrderedList a #

newtype Fixed a #

Fixed x: as x, but will not be shrunk.

Constructors

Fixed
Fields getFixed :: a

Instances

Instances details

Functor Fixed
Instance details Defined in Test.QuickCheck.Modifiers Methods fmap :: (a -> b) -> Fixed a -> Fixed b # (<$) :: a -> Fixed b -> Fixed a #
Arbitrary a => Arbitrary (Fixed a)
Instance details Defined in Test.QuickCheck.Modifiers Methods arbitrary :: Gen (Fixed a) # shrink :: Fixed a -> [Fixed a] #
Enum a => Enum (Fixed a)
Instance details Defined in Test.QuickCheck.Modifiers Methods succ :: Fixed a -> Fixed a # pred :: Fixed a -> Fixed a # toEnum :: Int -> Fixed a # fromEnum :: Fixed a -> Int # enumFrom :: Fixed a -> [Fixed a] # enumFromThen :: Fixed a -> Fixed a -> [Fixed a] # enumFromTo :: Fixed a -> Fixed a -> [Fixed a] # enumFromThenTo :: Fixed a -> Fixed a -> Fixed a -> [Fixed a] #
Num a => Num (Fixed a)
Instance details Defined in Test.QuickCheck.Modifiers Methods (+) :: Fixed a -> Fixed a -> Fixed a # (-) :: Fixed a -> Fixed a -> Fixed a # (*) :: Fixed a -> Fixed a -> Fixed a # negate :: Fixed a -> Fixed a # abs :: Fixed a -> Fixed a # signum :: Fixed a -> Fixed a # fromInteger :: Integer -> Fixed a #
Read a => Read (Fixed a)
Instance details Defined in Test.QuickCheck.Modifiers Methods readsPrec :: Int -> ReadS (Fixed a) # readList :: ReadS [Fixed a] # readPrec :: ReadPrec (Fixed a) # readListPrec :: ReadPrec [Fixed a] #
Integral a => Integral (Fixed a)
Instance details Defined in Test.QuickCheck.Modifiers Methods quot :: Fixed a -> Fixed a -> Fixed a # rem :: Fixed a -> Fixed a -> Fixed a # div :: Fixed a -> Fixed a -> Fixed a # mod :: Fixed a -> Fixed a -> Fixed a # quotRem :: Fixed a -> Fixed a -> (Fixed a, Fixed a) # divMod :: Fixed a -> Fixed a -> (Fixed a, Fixed a) # toInteger :: Fixed a -> Integer #
Real a => Real (Fixed a)
Instance details Defined in Test.QuickCheck.Modifiers Methods toRational :: Fixed a -> Rational #
Show a => Show (Fixed a)
Instance details Defined in Test.QuickCheck.Modifiers Methods showsPrec :: Int -> Fixed a -> ShowS # show :: Fixed a -> String # showList :: [Fixed a] -> ShowS #
Eq a => Eq (Fixed a)
Instance details Defined in Test.QuickCheck.Modifiers Methods (==) :: Fixed a -> Fixed a -> Bool # (/=) :: Fixed a -> Fixed a -> Bool #
Ord a => Ord (Fixed a)
Instance details Defined in Test.QuickCheck.Modifiers Methods compare :: Fixed a -> Fixed a -> Ordering # (<) :: Fixed a -> Fixed a -> Bool # (<=) :: Fixed a -> Fixed a -> Bool # (>) :: Fixed a -> Fixed a -> Bool # (>=) :: Fixed a -> Fixed a -> Bool # max :: Fixed a -> Fixed a -> Fixed a # min :: Fixed a -> Fixed a -> Fixed a #

newtype Blind a #

Blind x: as x, but x does not have to be in the Show class.

Constructors

Blind
Fields getBlind :: a

Instances

class Function a where #

The class Function a is used for random generation of showable functions of type a -> b.

There is a default implementation for function, which you can use if your type has structural equality. Otherwise, you can normally use functionMap or functionShow.

Minimal complete definition

Nothing

Methods

function :: (a -> b) -> a :-> b #

Instances

Instances details

Function A
Instance details Defined in Test.QuickCheck.Function Methods function :: (A -> b) -> A :-> b #
Function B
Instance details Defined in Test.QuickCheck.Function Methods function :: (B -> b) -> B :-> b #
Function C
Instance details Defined in Test.QuickCheck.Function Methods function :: (C -> b) -> C :-> b #
Function OrdA
Instance details Defined in Test.QuickCheck.Function Methods function :: (OrdA -> b) -> OrdA :-> b #
Function OrdB
Instance details Defined in Test.QuickCheck.Function Methods function :: (OrdB -> b) -> OrdB :-> b #
Function OrdC
Instance details Defined in Test.QuickCheck.Function Methods function :: (OrdC -> b) -> OrdC :-> b #
Function All
Instance details Defined in Test.QuickCheck.Function Methods function :: (All -> b) -> All :-> b #
Function Any
Instance details Defined in Test.QuickCheck.Function Methods function :: (Any -> b) -> Any :-> b #
Function Newline
Instance details Defined in Test.QuickCheck.Function Methods function :: (Newline -> b) -> Newline :-> b #
Function NewlineMode
Instance details Defined in Test.QuickCheck.Function Methods function :: (NewlineMode -> b) -> NewlineMode :-> b #
Function Int16
Instance details Defined in Test.QuickCheck.Function Methods function :: (Int16 -> b) -> Int16 :-> b #
Function Int32
Instance details Defined in Test.QuickCheck.Function Methods function :: (Int32 -> b) -> Int32 :-> b #
Function Int64
Instance details Defined in Test.QuickCheck.Function Methods function :: (Int64 -> b) -> Int64 :-> b #
Function Int8
Instance details Defined in Test.QuickCheck.Function Methods function :: (Int8 -> b) -> Int8 :-> b #
Function Word16
Instance details Defined in Test.QuickCheck.Function Methods function :: (Word16 -> b) -> Word16 :-> b #
Function Word32
Instance details Defined in Test.QuickCheck.Function Methods function :: (Word32 -> b) -> Word32 :-> b #
Function Word64
Instance details Defined in Test.QuickCheck.Function Methods function :: (Word64 -> b) -> Word64 :-> b #
Function Word8
Instance details Defined in Test.QuickCheck.Function Methods function :: (Word8 -> b) -> Word8 :-> b #
Function IntSet
Instance details Defined in Test.QuickCheck.Function Methods function :: (IntSet -> b) -> IntSet :-> b #
Function Ordering
Instance details Defined in Test.QuickCheck.Function Methods function :: (Ordering -> b) -> Ordering :-> b #
Function Integer
Instance details Defined in Test.QuickCheck.Function Methods function :: (Integer -> b) -> Integer :-> b #
Function ()
Instance details Defined in Test.QuickCheck.Function Methods function :: (() -> b) -> () :-> b #
Function Bool
Instance details Defined in Test.QuickCheck.Function Methods function :: (Bool -> b) -> Bool :-> b #
Function Char
Instance details Defined in Test.QuickCheck.Function Methods function :: (Char -> b) -> Char :-> b #
Function Double
Instance details Defined in Test.QuickCheck.Function Methods function :: (Double -> b) -> Double :-> b #
Function Float
Instance details Defined in Test.QuickCheck.Function Methods function :: (Float -> b) -> Float :-> b #
Function Int
Instance details Defined in Test.QuickCheck.Function Methods function :: (Int -> b) -> Int :-> b #
Function Word
Instance details Defined in Test.QuickCheck.Function Methods function :: (Word -> b) -> Word :-> b #
(RealFloat a, Function a) => Function (Complex a)
Instance details Defined in Test.QuickCheck.Function Methods function :: (Complex a -> b) -> Complex a :-> b #
Function a => Function (Identity a)
Instance details Defined in Test.QuickCheck.Function Methods function :: (Identity a -> b) -> Identity a :-> b #
Function a => Function (First a)
Instance details Defined in Test.QuickCheck.Function Methods function :: (First a -> b) -> First a :-> b #
Function a => Function (Last a)
Instance details Defined in Test.QuickCheck.Function Methods function :: (Last a -> b) -> Last a :-> b #
Function a => Function (Dual a)
Instance details Defined in Test.QuickCheck.Function Methods function :: (Dual a -> b) -> Dual a :-> b #
Function a => Function (Product a)
Instance details Defined in Test.QuickCheck.Function Methods function :: (Product a -> b) -> Product a :-> b #
Function a => Function (Sum a)
Instance details Defined in Test.QuickCheck.Function Methods function :: (Sum a -> b) -> Sum a :-> b #
(Integral a, Function a) => Function (Ratio a)
Instance details Defined in Test.QuickCheck.Function Methods function :: (Ratio a -> b) -> Ratio a :-> b #
Function a => Function (IntMap a)
Instance details Defined in Test.QuickCheck.Function Methods function :: (IntMap a -> b) -> IntMap a :-> b #
Function a => Function (Seq a)
Instance details Defined in Test.QuickCheck.Function Methods function :: (Seq a -> b) -> Seq a :-> b #
(Ord a, Function a) => Function (Set a)
Instance details Defined in Test.QuickCheck.Function Methods function :: (Set a -> b) -> Set a :-> b #
Function a => Function (Tree a)
Instance details Defined in Test.QuickCheck.Function Methods function :: (Tree a -> b) -> Tree a :-> b #
Function a => Function (Maybe a)
Instance details Defined in Test.QuickCheck.Function Methods function :: (Maybe a -> b) -> Maybe a :-> b #
Function a => Function [a]
Instance details Defined in Test.QuickCheck.Function Methods function :: ([a] -> b) -> [a] :-> b #
(Function a, Function b) => Function (Either a b)
Instance details Defined in Test.QuickCheck.Function Methods function :: (Either a b -> b0) -> Either a b :-> b0 #
HasResolution a => Function (Fixed a)
Instance details Defined in Test.QuickCheck.Function Methods function :: (Fixed a -> b) -> Fixed a :-> b #
(Ord a, Function a, Function b) => Function (Map a b)
Instance details Defined in Test.QuickCheck.Function Methods function :: (Map a b -> b0) -> Map a b :-> b0 #
(Function a, Function b) => Function (a, b)
Instance details Defined in Test.QuickCheck.Function Methods function :: ((a, b) -> b0) -> (a, b) :-> b0 #
Function a => Function (Const a b)
Instance details Defined in Test.QuickCheck.Function Methods function :: (Const a b -> b0) -> Const a b :-> b0 #
Function (f a) => Function (Alt f a)
Instance details Defined in Test.QuickCheck.Function Methods function :: (Alt f a -> b) -> Alt f a :-> b #
(Function a, Function b, Function c) => Function (a, b, c)
Instance details Defined in Test.QuickCheck.Function Methods function :: ((a, b, c) -> b0) -> (a, b, c) :-> b0 #
(Function a, Function b, Function c, Function d) => Function (a, b, c, d)
Instance details Defined in Test.QuickCheck.Function Methods function :: ((a, b, c, d) -> b0) -> (a, b, c, d) :-> b0 #
(Function a, Function b, Function c, Function d, Function e) => Function (a, b, c, d, e)
Instance details Defined in Test.QuickCheck.Function Methods function :: ((a, b, c, d, e) -> b0) -> (a, b, c, d, e) :-> b0 #
(Function a, Function b, Function c, Function d, Function e, Function f) => Function (a, b, c, d, e, f)
Instance details Defined in Test.QuickCheck.Function Methods function :: ((a, b, c, d, e, f) -> b0) -> (a, b, c, d, e, f) :-> b0 #
(Function a, Function b, Function c, Function d, Function e, Function f, Function g) => Function (a, b, c, d, e, f, g)
Instance details Defined in Test.QuickCheck.Function Methods function :: ((a, b, c, d, e, f, g) -> b0) -> (a, b, c, d, e, f, g) :-> b0 #

data Confidence #

The statistical parameters used by checkCoverage.

Constructors

Confidence

Fields

certainty :: Integer
How certain checkCoverage must be before the property fails. If the coverage requirement is met, and the certainty parameter is n, then you should get a false positive at most one in n runs of QuickCheck. The default value is 10^9.
Lower values will speed up checkCoverage at the cost of false positives.
If you are using checkCoverage as part of a test suite, you should be careful not to set certainty too low. If you want, say, a 1% chance of a false positive during a project's lifetime, then certainty should be set to at least 100 * m * n, where m is the number of uses of cover in the test suite, and n is the number of times you expect the test suite to be run during the project's lifetime. The default value is chosen to be big enough for most projects.
tolerance :: Double
For statistical reasons, checkCoverage will not reject coverage levels that are only slightly below the required levels. If the required level is p then an actual level of tolerance * p will be accepted. The default value is 0.9.
Lower values will speed up checkCoverage at the cost of not detecting minor coverage violations.

Instances

Instances details

Show Confidence
Instance details Defined in Test.QuickCheck.State Methods showsPrec :: Int -> Confidence -> ShowS # show :: Confidence -> String # showList :: [Confidence] -> ShowS #

data Witness #

Constructors

(Typeable a, Show a) => Wit a

Instances

Instances details

Show Witness
Instance details Defined in Test.QuickCheck.Property Methods showsPrec :: Int -> Witness -> ShowS # show :: Witness -> String # showList :: [Witness] -> ShowS #

data Discard #

If a property returns Discard, the current test case is discarded, the same as if a precondition was false.

An example is the definition of ==>:

(==>) :: Testable prop => Bool -> prop -> Property
False ==> _ = property Discard
True  ==> p = property p

Constructors

Discard

Instances

Instances details

Testable Discard
Instance details Defined in Test.QuickCheck.Property Methods property :: Discard -> Property # propertyForAllShrinkShow :: Gen a -> (a -> [a]) -> (a -> [String]) -> (a -> Discard) -> Property #

data Property #

The type of properties.

Instances

Instances details

Testable Property
Instance details Defined in Test.QuickCheck.Property Methods property :: Property -> Property # propertyForAllShrinkShow :: Gen a -> (a -> [a]) -> (a -> [String]) -> (a -> Property) -> Property #
type Arg Property
Instance details Defined in Test.Hspec.Core.QuickCheck type Arg Property = ()
type Arg (a -> Property)
Instance details Defined in Test.Hspec.Core.QuickCheck type Arg (a -> Property) = a

data Args #

Args specifies arguments to the QuickCheck driver

Constructors

Args

Fields

replay :: Maybe (QCGen, Int)
Should we replay a previous test? Note: saving a seed from one version of QuickCheck and replaying it in another is not supported. If you want to store a test case permanently you should save the test case itself.
maxSuccess :: Int
Maximum number of successful tests before succeeding. Testing stops at the first failure. If all tests are passing and you want to run more tests, increase this number.
maxDiscardRatio :: Int
Maximum number of discarded tests per successful test before giving up
maxSize :: Int
Size to use for the biggest test cases
chatty :: Bool
Whether to print anything
maxShrinks :: Int
Maximum number of shrinks to do before giving up. Setting this to zero turns shrinking off.

Instances

Instances details

Read Args
Instance details Defined in Test.QuickCheck.Test Methods readsPrec :: Int -> ReadS Args # readList :: ReadS [Args] # readPrec :: ReadPrec Args # readListPrec :: ReadPrec [Args] #
Show Args
Instance details Defined in Test.QuickCheck.Test Methods showsPrec :: Int -> Args -> ShowS # show :: Args -> String # showList :: [Args] -> ShowS #

newtype PropertyM (m :: Type -> Type) a #

The property monad is really a monad transformer that can contain monadic computations in the monad m it is parameterized by:

m - the m-computations that may be performed within PropertyM

Elements of PropertyM m a may mix property operations and m-computations.

Constructors

MkPropertyM
Fields unPropertyM :: (a -> Gen (m Property)) -> Gen (m Property)

Instances

Instances details

MonadTrans PropertyM
Instance details Defined in Test.QuickCheck.Monadic Methods lift :: Monad m => m a -> PropertyM m a #
Monad m => MonadFail (PropertyM m)
Instance details Defined in Test.QuickCheck.Monadic Methods fail :: String -> PropertyM m a #
MonadIO m => MonadIO (PropertyM m)
Instance details Defined in Test.QuickCheck.Monadic Methods liftIO :: IO a -> PropertyM m a #
Applicative (PropertyM m)
Instance details Defined in Test.QuickCheck.Monadic Methods pure :: a -> PropertyM m a # (<>) :: PropertyM m (a -> b) -> PropertyM m a -> PropertyM m b # liftA2 :: (a -> b -> c) -> PropertyM m a -> PropertyM m b -> PropertyM m c # (>) :: PropertyM m a -> PropertyM m b -> PropertyM m b # (<*) :: PropertyM m a -> PropertyM m b -> PropertyM m a #
Functor (PropertyM m)
Instance details Defined in Test.QuickCheck.Monadic Methods fmap :: (a -> b) -> PropertyM m a -> PropertyM m b # (<$) :: a -> PropertyM m b -> PropertyM m a #
Monad m => Monad (PropertyM m)
Instance details Defined in Test.QuickCheck.Monadic Methods (>>=) :: PropertyM m a -> (a -> PropertyM m b) -> PropertyM m b # (>>) :: PropertyM m a -> PropertyM m b -> PropertyM m b # return :: a -> PropertyM m a #

class Bounded a where #

The Bounded class is used to name the upper and lower limits of a type. Ord is not a superclass of Bounded since types that are not totally ordered may also have upper and lower bounds.

The Bounded class may be derived for any enumeration type; minBound is the first constructor listed in the data declaration and maxBound is the last. Bounded may also be derived for single-constructor datatypes whose constituent types are in Bounded.

Methods

minBound :: a #

maxBound :: a #

Instances

Instances details

Bounded IntPtr
Instance details Defined in Foreign.Ptr Methods minBound :: IntPtr # maxBound :: IntPtr #
Bounded WordPtr
Instance details Defined in Foreign.Ptr Methods minBound :: WordPtr # maxBound :: WordPtr #
Bounded Associativity	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods minBound :: Associativity # maxBound :: Associativity #
Bounded DecidedStrictness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods minBound :: DecidedStrictness # maxBound :: DecidedStrictness #
Bounded SourceStrictness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods minBound :: SourceStrictness # maxBound :: SourceStrictness #
Bounded SourceUnpackedness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods minBound :: SourceUnpackedness # maxBound :: SourceUnpackedness #
Bounded Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods minBound :: Word16 # maxBound :: Word16 #
Bounded Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods minBound :: Word32 # maxBound :: Word32 #
Bounded Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods minBound :: Word64 # maxBound :: Word64 #
Bounded Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods minBound :: Word8 # maxBound :: Word8 #
Bounded Ordering	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Ordering # maxBound :: Ordering #
Bounded ()	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: () # maxBound :: () #
Bounded Bool	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Bool # maxBound :: Bool #
Bounded Char	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Char # maxBound :: Char #
Bounded Int	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Int # maxBound :: Int #
Bounded Levity	Since: base-4.16.0.0
Instance details Defined in GHC.Enum Methods minBound :: Levity # maxBound :: Levity #
Bounded VecCount	Since: base-4.10.0.0
Instance details Defined in GHC.Enum Methods minBound :: VecCount # maxBound :: VecCount #
Bounded VecElem	Since: base-4.10.0.0
Instance details Defined in GHC.Enum Methods minBound :: VecElem # maxBound :: VecElem #
Bounded Word	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: Word # maxBound :: Word #
Bounded a => Bounded (And a)	Since: base-4.16
Instance details Defined in Data.Bits Methods minBound :: And a # maxBound :: And a #
Bounded a => Bounded (Iff a)	Since: base-4.16
Instance details Defined in Data.Bits Methods minBound :: Iff a # maxBound :: Iff a #
Bounded a => Bounded (Ior a)	Since: base-4.16
Instance details Defined in Data.Bits Methods minBound :: Ior a # maxBound :: Ior a #
Bounded a => Bounded (Xor a)	Since: base-4.16
Instance details Defined in Data.Bits Methods minBound :: Xor a # maxBound :: Xor a #
Bounded w => Bounded (BE w)
Instance details Defined in Raaz.Core.Types.Endian Methods minBound :: BE w # maxBound :: BE w #
Bounded w => Bounded (LE w)
Instance details Defined in Raaz.Core.Types.Endian Methods minBound :: LE w # maxBound :: LE w #
Bounded a => Bounded (BYTES a)
Instance details Defined in Raaz.Core.Types.Pointer Methods minBound :: BYTES a # maxBound :: BYTES a #
Bounded a => Bounded (a)
Instance details Defined in GHC.Enum Methods minBound :: (a) # maxBound :: (a) #
Bounded (Proxy t)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods minBound :: Proxy t # maxBound :: Proxy t #
(Bounded a, Bounded b) => Bounded (a, b)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b) # maxBound :: (a, b) #
Bounded a => Bounded (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods minBound :: Const a b # maxBound :: Const a b #
(Bounded a, Bounded b, Bounded c) => Bounded (a, b, c)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c) # maxBound :: (a, b, c) #
(Bounded a, Bounded b, Bounded c, Bounded d) => Bounded (a, b, c, d)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c, d) # maxBound :: (a, b, c, d) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e) => Bounded (a, b, c, d, e)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c, d, e) # maxBound :: (a, b, c, d, e) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f) => Bounded (a, b, c, d, e, f)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c, d, e, f) # maxBound :: (a, b, c, d, e, f) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g) => Bounded (a, b, c, d, e, f, g)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c, d, e, f, g) # maxBound :: (a, b, c, d, e, f, g) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h) => Bounded (a, b, c, d, e, f, g, h)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c, d, e, f, g, h) # maxBound :: (a, b, c, d, e, f, g, h) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i) => Bounded (a, b, c, d, e, f, g, h, i)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c, d, e, f, g, h, i) # maxBound :: (a, b, c, d, e, f, g, h, i) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j) => Bounded (a, b, c, d, e, f, g, h, i, j)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c, d, e, f, g, h, i, j) # maxBound :: (a, b, c, d, e, f, g, h, i, j) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k) => Bounded (a, b, c, d, e, f, g, h, i, j, k)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c, d, e, f, g, h, i, j, k) # maxBound :: (a, b, c, d, e, f, g, h, i, j, k) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l) => Bounded (a, b, c, d, e, f, g, h, i, j, k, l)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c, d, e, f, g, h, i, j, k, l) # maxBound :: (a, b, c, d, e, f, g, h, i, j, k, l) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l, Bounded m) => Bounded (a, b, c, d, e, f, g, h, i, j, k, l, m)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m) # maxBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l, Bounded m, Bounded n) => Bounded (a, b, c, d, e, f, g, h, i, j, k, l, m, n)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) # maxBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) #
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l, Bounded m, Bounded n, Bounded o) => Bounded (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)	Since: base-2.1
Instance details Defined in GHC.Enum Methods minBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) # maxBound :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) #

class Enum a where #

Class Enum defines operations on sequentially ordered types.

The enumFrom... methods are used in Haskell's translation of arithmetic sequences.

Instances of Enum may be derived for any enumeration type (types whose constructors have no fields). The nullary constructors are assumed to be numbered left-to-right by fromEnum from 0 through n-1. See Chapter 10 of the Haskell Report for more details.

For any type that is an instance of class Bounded as well as Enum, the following should hold:

The calls succ maxBound and pred minBound should result in a runtime error.
fromEnum and toEnum should give a runtime error if the result value is not representable in the result type. For example, toEnum 7 :: Bool is an error.
enumFrom and enumFromThen should be defined with an implicit bound, thus:

   enumFrom     x   = enumFromTo     x maxBound
   enumFromThen x y = enumFromThenTo x y bound
     where
       bound | fromEnum y >= fromEnum x = maxBound
             | otherwise                = minBound

Minimal complete definition

toEnum, fromEnum

Methods

succ :: a -> a #

the successor of a value. For numeric types, succ adds 1.

pred :: a -> a #

the predecessor of a value. For numeric types, pred subtracts 1.

toEnum :: Int -> a #

Convert from an Int.

fromEnum :: a -> Int #

Convert to an Int. It is implementation-dependent what fromEnum returns when applied to a value that is too large to fit in an Int.

enumFrom :: a -> [a] #

Used in Haskell's translation of [n..] with [n..] = enumFrom n, a possible implementation being enumFrom n = n : enumFrom (succ n). For example:

```
enumFrom 4 :: [Integer] = [4,5,6,7,...]
```

enumFrom 6 :: [Int] = [6,7,8,9,...,maxBound :: Int]

enumFromThen :: a -> a -> [a] #

Used in Haskell's translation of [n,n'..] with [n,n'..] = enumFromThen n n', a possible implementation being enumFromThen n n' = n : n' : worker (f x) (f x n'), worker s v = v : worker s (s v), x = fromEnum n' - fromEnum n and f n y | n > 0 = f (n - 1) (succ y) | n < 0 = f (n + 1) (pred y) | otherwise = y For example:

enumFromThen 4 6 :: [Integer] = [4,6,8,10...]

enumFromThen 6 2 :: [Int] = [6,2,-2,-6,...,minBound :: Int]

enumFromTo :: a -> a -> [a] #

Used in Haskell's translation of [n..m] with [n..m] = enumFromTo n m, a possible implementation being enumFromTo n m | n <= m = n : enumFromTo (succ n) m | otherwise = []. For example:

```
enumFromTo 6 10 :: [Int] = [6,7,8,9,10]
```
```
enumFromTo 42 1 :: [Integer] = []
```

enumFromThenTo :: a -> a -> a -> [a] #

Used in Haskell's translation of [n,n'..m] with [n,n'..m] = enumFromThenTo n n' m, a possible implementation being enumFromThenTo n n' m = worker (f x) (c x) n m, x = fromEnum n' - fromEnum n, c x = bool (>=) ((x 0) f n y | n > 0 = f (n - 1) (succ y) | n < 0 = f (n + 1) (pred y) | otherwise = y and worker s c v m | c v m = v : worker s c (s v) m | otherwise = [] For example:

enumFromThenTo 4 2 -6 :: [Integer] = [4,2,0,-2,-4,-6]

```
enumFromThenTo 6 8 2 :: [Int] = []
```

Instances

Instances details

Enum IntPtr
Instance details Defined in Foreign.Ptr Methods succ :: IntPtr -> IntPtr # pred :: IntPtr -> IntPtr # toEnum :: Int -> IntPtr # fromEnum :: IntPtr -> Int # enumFrom :: IntPtr -> [IntPtr] # enumFromThen :: IntPtr -> IntPtr -> [IntPtr] # enumFromTo :: IntPtr -> IntPtr -> [IntPtr] # enumFromThenTo :: IntPtr -> IntPtr -> IntPtr -> [IntPtr] #
Enum WordPtr
Instance details Defined in Foreign.Ptr Methods succ :: WordPtr -> WordPtr # pred :: WordPtr -> WordPtr # toEnum :: Int -> WordPtr # fromEnum :: WordPtr -> Int # enumFrom :: WordPtr -> [WordPtr] # enumFromThen :: WordPtr -> WordPtr -> [WordPtr] # enumFromTo :: WordPtr -> WordPtr -> [WordPtr] # enumFromThenTo :: WordPtr -> WordPtr -> WordPtr -> [WordPtr] #
Enum Associativity	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods succ :: Associativity -> Associativity # pred :: Associativity -> Associativity # toEnum :: Int -> Associativity # fromEnum :: Associativity -> Int # enumFrom :: Associativity -> [Associativity] # enumFromThen :: Associativity -> Associativity -> [Associativity] # enumFromTo :: Associativity -> Associativity -> [Associativity] # enumFromThenTo :: Associativity -> Associativity -> Associativity -> [Associativity] #
Enum DecidedStrictness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods succ :: DecidedStrictness -> DecidedStrictness # pred :: DecidedStrictness -> DecidedStrictness # toEnum :: Int -> DecidedStrictness # fromEnum :: DecidedStrictness -> Int # enumFrom :: DecidedStrictness -> [DecidedStrictness] # enumFromThen :: DecidedStrictness -> DecidedStrictness -> [DecidedStrictness] # enumFromTo :: DecidedStrictness -> DecidedStrictness -> [DecidedStrictness] # enumFromThenTo :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness -> [DecidedStrictness] #
Enum SourceStrictness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods succ :: SourceStrictness -> SourceStrictness # pred :: SourceStrictness -> SourceStrictness # toEnum :: Int -> SourceStrictness # fromEnum :: SourceStrictness -> Int # enumFrom :: SourceStrictness -> [SourceStrictness] # enumFromThen :: SourceStrictness -> SourceStrictness -> [SourceStrictness] # enumFromTo :: SourceStrictness -> SourceStrictness -> [SourceStrictness] # enumFromThenTo :: SourceStrictness -> SourceStrictness -> SourceStrictness -> [SourceStrictness] #
Enum SourceUnpackedness	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods succ :: SourceUnpackedness -> SourceUnpackedness # pred :: SourceUnpackedness -> SourceUnpackedness # toEnum :: Int -> SourceUnpackedness # fromEnum :: SourceUnpackedness -> Int # enumFrom :: SourceUnpackedness -> [SourceUnpackedness] # enumFromThen :: SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness] # enumFromTo :: SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness] # enumFromThenTo :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness] #
Enum SeekMode	Since: base-4.2.0.0
Instance details Defined in GHC.IO.Device Methods succ :: SeekMode -> SeekMode # pred :: SeekMode -> SeekMode # toEnum :: Int -> SeekMode # fromEnum :: SeekMode -> Int # enumFrom :: SeekMode -> [SeekMode] # enumFromThen :: SeekMode -> SeekMode -> [SeekMode] # enumFromTo :: SeekMode -> SeekMode -> [SeekMode] # enumFromThenTo :: SeekMode -> SeekMode -> SeekMode -> [SeekMode] #
Enum IOMode	Since: base-4.2.0.0
Instance details Defined in GHC.IO.IOMode Methods succ :: IOMode -> IOMode # pred :: IOMode -> IOMode # toEnum :: Int -> IOMode # fromEnum :: IOMode -> Int # enumFrom :: IOMode -> [IOMode] # enumFromThen :: IOMode -> IOMode -> [IOMode] # enumFromTo :: IOMode -> IOMode -> [IOMode] # enumFromThenTo :: IOMode -> IOMode -> IOMode -> [IOMode] #
Enum Word16	Since: base-2.1
Instance details Defined in GHC.Word Methods succ :: Word16 -> Word16 # pred :: Word16 -> Word16 # toEnum :: Int -> Word16 # fromEnum :: Word16 -> Int # enumFrom :: Word16 -> [Word16] # enumFromThen :: Word16 -> Word16 -> [Word16] # enumFromTo :: Word16 -> Word16 -> [Word16] # enumFromThenTo :: Word16 -> Word16 -> Word16 -> [Word16] #
Enum Word32	Since: base-2.1
Instance details Defined in GHC.Word Methods succ :: Word32 -> Word32 # pred :: Word32 -> Word32 # toEnum :: Int -> Word32 # fromEnum :: Word32 -> Int # enumFrom :: Word32 -> [Word32] # enumFromThen :: Word32 -> Word32 -> [Word32] # enumFromTo :: Word32 -> Word32 -> [Word32] # enumFromThenTo :: Word32 -> Word32 -> Word32 -> [Word32] #
Enum Word64	Since: base-2.1
Instance details Defined in GHC.Word Methods succ :: Word64 -> Word64 # pred :: Word64 -> Word64 # toEnum :: Int -> Word64 # fromEnum :: Word64 -> Int # enumFrom :: Word64 -> [Word64] # enumFromThen :: Word64 -> Word64 -> [Word64] # enumFromTo :: Word64 -> Word64 -> [Word64] # enumFromThenTo :: Word64 -> Word64 -> Word64 -> [Word64] #
Enum Word8	Since: base-2.1
Instance details Defined in GHC.Word Methods succ :: Word8 -> Word8 # pred :: Word8 -> Word8 # toEnum :: Int -> Word8 # fromEnum :: Word8 -> Int # enumFrom :: Word8 -> [Word8] # enumFromThen :: Word8 -> Word8 -> [Word8] # enumFromTo :: Word8 -> Word8 -> [Word8] # enumFromThenTo :: Word8 -> Word8 -> Word8 -> [Word8] #
Enum Ordering	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Ordering -> Ordering # pred :: Ordering -> Ordering # toEnum :: Int -> Ordering # fromEnum :: Ordering -> Int # enumFrom :: Ordering -> [Ordering] # enumFromThen :: Ordering -> Ordering -> [Ordering] # enumFromTo :: Ordering -> Ordering -> [Ordering] # enumFromThenTo :: Ordering -> Ordering -> Ordering -> [Ordering] #
Enum Alignment
Instance details Defined in Raaz.Core.Types.Pointer Methods succ :: Alignment -> Alignment # pred :: Alignment -> Alignment # toEnum :: Int -> Alignment # fromEnum :: Alignment -> Int # enumFrom :: Alignment -> [Alignment] # enumFromThen :: Alignment -> Alignment -> [Alignment] # enumFromTo :: Alignment -> Alignment -> [Alignment] # enumFromThenTo :: Alignment -> Alignment -> Alignment -> [Alignment] #
Enum Integer	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Integer -> Integer # pred :: Integer -> Integer # toEnum :: Int -> Integer # fromEnum :: Integer -> Int # enumFrom :: Integer -> [Integer] # enumFromThen :: Integer -> Integer -> [Integer] # enumFromTo :: Integer -> Integer -> [Integer] # enumFromThenTo :: Integer -> Integer -> Integer -> [Integer] #
Enum Natural	Since: base-4.8.0.0
Instance details Defined in GHC.Enum Methods succ :: Natural -> Natural # pred :: Natural -> Natural # toEnum :: Int -> Natural # fromEnum :: Natural -> Int # enumFrom :: Natural -> [Natural] # enumFromThen :: Natural -> Natural -> [Natural] # enumFromTo :: Natural -> Natural -> [Natural] # enumFromThenTo :: Natural -> Natural -> Natural -> [Natural] #
Enum ()	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: () -> () # pred :: () -> () # toEnum :: Int -> () # fromEnum :: () -> Int # enumFrom :: () -> [()] # enumFromThen :: () -> () -> [()] # enumFromTo :: () -> () -> [()] # enumFromThenTo :: () -> () -> () -> [()] #
Enum Bool	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Bool -> Bool # pred :: Bool -> Bool # toEnum :: Int -> Bool # fromEnum :: Bool -> Int # enumFrom :: Bool -> [Bool] # enumFromThen :: Bool -> Bool -> [Bool] # enumFromTo :: Bool -> Bool -> [Bool] # enumFromThenTo :: Bool -> Bool -> Bool -> [Bool] #
Enum Char	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Char -> Char # pred :: Char -> Char # toEnum :: Int -> Char # fromEnum :: Char -> Int # enumFrom :: Char -> [Char] # enumFromThen :: Char -> Char -> [Char] # enumFromTo :: Char -> Char -> [Char] # enumFromThenTo :: Char -> Char -> Char -> [Char] #
Enum Int	Since: base-2.1
Instance details Defined in GHC.Enum 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] #
Enum Levity	Since: base-4.16.0.0
Instance details Defined in GHC.Enum Methods succ :: Levity -> Levity # pred :: Levity -> Levity # toEnum :: Int -> Levity # fromEnum :: Levity -> Int # enumFrom :: Levity -> [Levity] # enumFromThen :: Levity -> Levity -> [Levity] # enumFromTo :: Levity -> Levity -> [Levity] # enumFromThenTo :: Levity -> Levity -> Levity -> [Levity] #
Enum VecCount	Since: base-4.10.0.0
Instance details Defined in GHC.Enum Methods succ :: VecCount -> VecCount # pred :: VecCount -> VecCount # toEnum :: Int -> VecCount # fromEnum :: VecCount -> Int # enumFrom :: VecCount -> [VecCount] # enumFromThen :: VecCount -> VecCount -> [VecCount] # enumFromTo :: VecCount -> VecCount -> [VecCount] # enumFromThenTo :: VecCount -> VecCount -> VecCount -> [VecCount] #
Enum VecElem	Since: base-4.10.0.0
Instance details Defined in GHC.Enum Methods succ :: VecElem -> VecElem # pred :: VecElem -> VecElem # toEnum :: Int -> VecElem # fromEnum :: VecElem -> Int # enumFrom :: VecElem -> [VecElem] # enumFromThen :: VecElem -> VecElem -> [VecElem] # enumFromTo :: VecElem -> VecElem -> [VecElem] # enumFromThenTo :: VecElem -> VecElem -> VecElem -> [VecElem] #
Enum Word	Since: base-2.1
Instance details Defined in GHC.Enum Methods succ :: Word -> Word # pred :: Word -> Word # toEnum :: Int -> Word # fromEnum :: Word -> Int # enumFrom :: Word -> [Word] # enumFromThen :: Word -> Word -> [Word] # enumFromTo :: Word -> Word -> [Word] # enumFromThenTo :: Word -> Word -> Word -> [Word] #
Enum a => Enum (Blind a)
Instance details Defined in Test.QuickCheck.Modifiers Methods succ :: Blind a -> Blind a # pred :: Blind a -> Blind a # toEnum :: Int -> Blind a # fromEnum :: Blind a -> Int # enumFrom :: Blind a -> [Blind a] # enumFromThen :: Blind a -> Blind a -> [Blind a] # enumFromTo :: Blind a -> Blind a -> [Blind a] # enumFromThenTo :: Blind a -> Blind a -> Blind a -> [Blind a] #
Enum a => Enum (Fixed a)
Instance details Defined in Test.QuickCheck.Modifiers Methods succ :: Fixed a -> Fixed a # pred :: Fixed a -> Fixed a # toEnum :: Int -> Fixed a # fromEnum :: Fixed a -> Int # enumFrom :: Fixed a -> [Fixed a] # enumFromThen :: Fixed a -> Fixed a -> [Fixed a] # enumFromTo :: Fixed a -> Fixed a -> [Fixed a] # enumFromThenTo :: Fixed a -> Fixed a -> Fixed a -> [Fixed a] #
Enum a => Enum (Large a)
Instance details Defined in Test.QuickCheck.Modifiers Methods succ :: Large a -> Large a # pred :: Large a -> Large a # toEnum :: Int -> Large a # fromEnum :: Large a -> Int # enumFrom :: Large a -> [Large a] # enumFromThen :: Large a -> Large a -> [Large a] # enumFromTo :: Large a -> Large a -> [Large a] # enumFromThenTo :: Large a -> Large a -> Large a -> [Large a] #
Enum a => Enum (Negative a)
Instance details Defined in Test.QuickCheck.Modifiers Methods succ :: Negative a -> Negative a # pred :: Negative a -> Negative a # toEnum :: Int -> Negative a # fromEnum :: Negative a -> Int # enumFrom :: Negative a -> [Negative a] # enumFromThen :: Negative a -> Negative a -> [Negative a] # enumFromTo :: Negative a -> Negative a -> [Negative a] # enumFromThenTo :: Negative a -> Negative a -> Negative a -> [Negative a] #
Enum a => Enum (NonNegative a)
Instance details Defined in Test.QuickCheck.Modifiers Methods succ :: NonNegative a -> NonNegative a # pred :: NonNegative a -> NonNegative a # toEnum :: Int -> NonNegative a # fromEnum :: NonNegative a -> Int # enumFrom :: NonNegative a -> [NonNegative a] # enumFromThen :: NonNegative a -> NonNegative a -> [NonNegative a] # enumFromTo :: NonNegative a -> NonNegative a -> [NonNegative a] # enumFromThenTo :: NonNegative a -> NonNegative a -> NonNegative a -> [NonNegative a] #
Enum a => Enum (NonPositive a)
Instance details Defined in Test.QuickCheck.Modifiers Methods succ :: NonPositive a -> NonPositive a # pred :: NonPositive a -> NonPositive a # toEnum :: Int -> NonPositive a # fromEnum :: NonPositive a -> Int # enumFrom :: NonPositive a -> [NonPositive a] # enumFromThen :: NonPositive a -> NonPositive a -> [NonPositive a] # enumFromTo :: NonPositive a -> NonPositive a -> [NonPositive a] # enumFromThenTo :: NonPositive a -> NonPositive a -> NonPositive a -> [NonPositive a] #
Enum a => Enum (NonZero a)
Instance details Defined in Test.QuickCheck.Modifiers Methods succ :: NonZero a -> NonZero a # pred :: NonZero a -> NonZero a # toEnum :: Int -> NonZero a # fromEnum :: NonZero a -> Int # enumFrom :: NonZero a -> [NonZero a] # enumFromThen :: NonZero a -> NonZero a -> [NonZero a] # enumFromTo :: NonZero a -> NonZero a -> [NonZero a] # enumFromThenTo :: NonZero a -> NonZero a -> NonZero a -> [NonZero a] #
Enum a => Enum (Positive a)
Instance details Defined in Test.QuickCheck.Modifiers Methods succ :: Positive a -> Positive a # pred :: Positive a -> Positive a # toEnum :: Int -> Positive a # fromEnum :: Positive a -> Int # enumFrom :: Positive a -> [Positive a] # enumFromThen :: Positive a -> Positive a -> [Positive a] # enumFromTo :: Positive a -> Positive a -> [Positive a] # enumFromThenTo :: Positive a -> Positive a -> Positive a -> [Positive a] #
Enum a => Enum (Shrink2 a)
Instance details Defined in Test.QuickCheck.Modifiers Methods succ :: Shrink2 a -> Shrink2 a # pred :: Shrink2 a -> Shrink2 a # toEnum :: Int -> Shrink2 a # fromEnum :: Shrink2 a -> Int # enumFrom :: Shrink2 a -> [Shrink2 a] # enumFromThen :: Shrink2 a -> Shrink2 a -> [Shrink2 a] # enumFromTo :: Shrink2 a -> Shrink2 a -> [Shrink2 a] # enumFromThenTo :: Shrink2 a -> Shrink2 a -> Shrink2 a -> [Shrink2 a] #
Enum a => Enum (Small a)
Instance details Defined in Test.QuickCheck.Modifiers Methods succ :: Small a -> Small a # pred :: Small a -> Small a # toEnum :: Int -> Small a # fromEnum :: Small a -> Int # enumFrom :: Small a -> [Small a] # enumFromThen :: Small a -> Small a -> [Small a] # enumFromTo :: Small a -> Small a -> [Small a] # enumFromThenTo :: Small a -> Small a -> Small a -> [Small a] #
Enum a => Enum (And a)	Since: base-4.16
Instance details Defined in Data.Bits Methods succ :: And a -> And a # pred :: And a -> And a # toEnum :: Int -> And a # fromEnum :: And a -> Int # enumFrom :: And a -> [And a] # enumFromThen :: And a -> And a -> [And a] # enumFromTo :: And a -> And a -> [And a] # enumFromThenTo :: And a -> And a -> And a -> [And a] #
Enum a => Enum (Iff a)	Since: base-4.16
Instance details Defined in Data.Bits Methods succ :: Iff a -> Iff a # pred :: Iff a -> Iff a # toEnum :: Int -> Iff a # fromEnum :: Iff a -> Int # enumFrom :: Iff a -> [Iff a] # enumFromThen :: Iff a -> Iff a -> [Iff a] # enumFromTo :: Iff a -> Iff a -> [Iff a] # enumFromThenTo :: Iff a -> Iff a -> Iff a -> [Iff a] #
Enum a => Enum (Ior a)	Since: base-4.16
Instance details Defined in Data.Bits Methods succ :: Ior a -> Ior a # pred :: Ior a -> Ior a # toEnum :: Int -> Ior a # fromEnum :: Ior a -> Int # enumFrom :: Ior a -> [Ior a] # enumFromThen :: Ior a -> Ior a -> [Ior a] # enumFromTo :: Ior a -> Ior a -> [Ior a] # enumFromThenTo :: Ior a -> Ior a -> Ior a -> [Ior a] #
Enum a => Enum (Xor a)	Since: base-4.16
Instance details Defined in Data.Bits Methods succ :: Xor a -> Xor a # pred :: Xor a -> Xor a # toEnum :: Int -> Xor a # fromEnum :: Xor a -> Int # enumFrom :: Xor a -> [Xor a] # enumFromThen :: Xor a -> Xor a -> [Xor a] # enumFromTo :: Xor a -> Xor a -> [Xor a] # enumFromThenTo :: Xor a -> Xor a -> Xor a -> [Xor a] #
Integral a => Enum (Ratio a)	Since: base-2.0.1
Instance details Defined in GHC.Real Methods succ :: Ratio a -> Ratio a # pred :: Ratio a -> Ratio a # toEnum :: Int -> Ratio a # fromEnum :: Ratio a -> Int # enumFrom :: Ratio a -> [Ratio a] # enumFromThen :: Ratio a -> Ratio a -> [Ratio a] # enumFromTo :: Ratio a -> Ratio a -> [Ratio a] # enumFromThenTo :: Ratio a -> Ratio a -> Ratio a -> [Ratio a] #
Enum (BlockCount p)
Instance details Defined in Raaz.Core.Primitive Methods succ :: BlockCount p -> BlockCount p # pred :: BlockCount p -> BlockCount p # toEnum :: Int -> BlockCount p # fromEnum :: BlockCount p -> Int # enumFrom :: BlockCount p -> [BlockCount p] # enumFromThen :: BlockCount p -> BlockCount p -> [BlockCount p] # enumFromTo :: BlockCount p -> BlockCount p -> [BlockCount p] # enumFromThenTo :: BlockCount p -> BlockCount p -> BlockCount p -> [BlockCount p] #
Enum w => Enum (BE w)
Instance details Defined in Raaz.Core.Types.Endian Methods succ :: BE w -> BE w # pred :: BE w -> BE w # toEnum :: Int -> BE w # fromEnum :: BE w -> Int # enumFrom :: BE w -> [BE w] # enumFromThen :: BE w -> BE w -> [BE w] # enumFromTo :: BE w -> BE w -> [BE w] # enumFromThenTo :: BE w -> BE w -> BE w -> [BE w] #
Enum w => Enum (LE w)
Instance details Defined in Raaz.Core.Types.Endian Methods succ :: LE w -> LE w # pred :: LE w -> LE w # toEnum :: Int -> LE w # fromEnum :: LE w -> Int # enumFrom :: LE w -> [LE w] # enumFromThen :: LE w -> LE w -> [LE w] # enumFromTo :: LE w -> LE w -> [LE w] # enumFromThenTo :: LE w -> LE w -> LE w -> [LE w] #
Enum a => Enum (BYTES a)
Instance details Defined in Raaz.Core.Types.Pointer Methods succ :: BYTES a -> BYTES a # pred :: BYTES a -> BYTES a # toEnum :: Int -> BYTES a # fromEnum :: BYTES a -> Int # enumFrom :: BYTES a -> [BYTES a] # enumFromThen :: BYTES a -> BYTES a -> [BYTES a] # enumFromTo :: BYTES a -> BYTES a -> [BYTES a] # enumFromThenTo :: BYTES a -> BYTES a -> BYTES a -> [BYTES a] #
Enum a => Enum (a)
Instance details Defined in GHC.Enum Methods succ :: (a) -> (a) # pred :: (a) -> (a) # toEnum :: Int -> (a) # fromEnum :: (a) -> Int # enumFrom :: (a) -> [(a)] # enumFromThen :: (a) -> (a) -> [(a)] # enumFromTo :: (a) -> (a) -> [(a)] # enumFromThenTo :: (a) -> (a) -> (a) -> [(a)] #
Enum (Proxy s)	Since: base-4.7.0.0
Instance details Defined in Data.Proxy Methods succ :: Proxy s -> Proxy s # pred :: Proxy s -> Proxy s # toEnum :: Int -> Proxy s # fromEnum :: Proxy s -> Int # enumFrom :: Proxy s -> [Proxy s] # enumFromThen :: Proxy s -> Proxy s -> [Proxy s] # enumFromTo :: Proxy s -> Proxy s -> [Proxy s] # enumFromThenTo :: Proxy s -> Proxy s -> Proxy s -> [Proxy s] #
Enum a => Enum (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods succ :: Const a b -> Const a b # pred :: Const a b -> Const a b # toEnum :: Int -> Const a b # fromEnum :: Const a b -> Int # enumFrom :: Const a b -> [Const a b] # enumFromThen :: Const a b -> Const a b -> [Const a b] # enumFromTo :: Const a b -> Const a b -> [Const a b] # enumFromThenTo :: Const a b -> Const a b -> Const a b -> [Const a b] #

class (Real a, Fractional a) => RealFrac a where #

Extracting components of fractions.

Minimal complete definition

properFraction

Methods

properFraction :: Integral b => a -> (b, a) #

The function properFraction takes a real fractional number x and returns a pair (n,f) such that x = n+f, and:

n is an integral number with the same sign as x; and
f is a fraction with the same type and sign as x, and with absolute value less than 1.

The default definitions of the ceiling, floor, truncate and round functions are in terms of properFraction.

truncate :: Integral b => a -> b #

truncate x returns the integer nearest x between zero and x

round :: Integral b => a -> b #

round x returns the nearest integer to x; the even integer if x is equidistant between two integers

ceiling :: Integral b => a -> b #

ceiling x returns the least integer not less than x

floor :: Integral b => a -> b #

floor x returns the greatest integer not greater than x

Instances

Instances details

Integral a => RealFrac (Ratio a)	Since: base-2.0.1
Instance details Defined in GHC.Real Methods properFraction :: Integral b => Ratio a -> (b, Ratio a) # truncate :: Integral b => Ratio a -> b # round :: Integral b => Ratio a -> b # ceiling :: Integral b => Ratio a -> b # floor :: Integral b => Ratio a -> b #
RealFrac a => RealFrac (Const a b)	Since: base-4.9.0.0
Instance details Defined in Data.Functor.Const Methods properFraction :: Integral b0 => Const a b -> (b0, Const a b) # truncate :: Integral b0 => Const a b -> b0 # round :: Integral b0 => Const a b -> b0 # ceiling :: Integral b0 => Const a b -> b0 # floor :: Integral b0 => Const a b -> b0 #

class (Real a, Enum a) => Integral a where #

Integral numbers, supporting integer division.

The Haskell Report defines no laws for Integral. However, Integral instances are customarily expected to define a Euclidean domain and have the following properties for the div/mod and quot/rem pairs, given suitable Euclidean functions f and g:

x = y * quot x y + rem x y with rem x y = fromInteger 0 or g (rem x y) < g y
x = y * div x y + mod x y with mod x y = fromInteger 0 or f (mod x y) < f y

An example of a suitable Euclidean function, for Integer's instance, is abs.

In addition, toInteger should be total, and fromInteger should be a left inverse for it, i.e. fromInteger (toInteger i) = i.

Minimal complete definition

quotRem, toInteger

Methods

quot :: a -> a -> a infixl 7 #

integer division truncated toward zero